griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

minor formatting edits

Browse Source
This commit is contained in:
Campbell Barton
2011-12-21 04:56:04 +00:00
parent 57e6ac47a0
commit 8a8cb2c3ef
27 changed files with 404 additions and 395 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
source/blender/bmesh/editmesh_tools.c
View File

@@ -2356,7 +2356,7 @@ static void fill_quad_singlevert(EditFace *efa, struct GHash *gh)
X-------- --------X
*/
if(v[left]->f1){
if(v[left]->f1) {
//triangle is composed of cutvert, end and left
hold = addfacelist(verts[1],v[end],v[left],NULL, NULL,NULL);
hold->e1->f2 |= EDGENEW;
@@ -2374,7 +2374,7 @@ static void fill_quad_singlevert(EditFace *efa, struct GHash *gh)
hold->e1->f2 |= EDGEINNER;
facecopy(efa, hold);
}
else if(v[right]->f1){
else if(v[right]->f1) {
//triangle is composed of cutvert, right and start
hold = addfacelist(verts[1],v[right],v[start], NULL, NULL, NULL);
hold->e1->f2 |= EDGENEW;
@@ -2442,7 +2442,7 @@ void esubdivideflag(int flag, float rad, int beauty, int numcuts, int seltype)
if(mmd->flag & MOD_MIR_CLIPPING) {
for (eve= em->verts.first; eve; eve= eve->next) {
eve->f2= 0;
switch(mmd->axis){
switch(mmd->axis) {
case 0:
if (fabs(eve->co[0]) < mmd->tolerance)
eve->f2 |= 1;

28
source/blender/bmesh/intern/bmesh_construct.c
View File

@@ -109,7 +109,7 @@ BMEdge *BM_Make_Edge(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge *example, int nod
if(nodouble) /*test if edge already exists.*/
e = BM_Edge_Exist(v1, v2);
if(!e){
if(!e) {
e = bmesh_me(bm, v1, v2);
if(example)
@@ -138,8 +138,9 @@ BMEdge *BM_Make_Edge(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge *example, int nod
*
*/
BMFace *BM_Make_Face_QuadTri(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v3,
BMVert *v4, const BMFace *example, int nodouble)
BMFace *BM_Make_Face_QuadTri(BMesh *bm,
BMVert *v1, BMVert *v2, BMVert *v3, BMVert *v4,
const BMFace *example, int nodouble)
{
BMEdge *edar[4];
BMVert *vtar[4];
@@ -172,37 +173,40 @@ BMFace *BM_Make_Face_QuadTri_v(BMesh *bm, BMVert **verts, BMEdge **edges, int le
edar[0] = edar[1] = edar[2] = edar[3] = NULL;
if(edges){
if(edges) {
edar[0] = edges[0];
edar[1] = edges[1];
edar[2] = edges[2];
if(len == 4) edar[3] = edges[3];
}else{
}
else {
edar[0] = BM_Edge_Exist(verts[0],verts[1]);
edar[1] = BM_Edge_Exist(verts[1],verts[2]);
if(len == 4){
if(len == 4) {
edar[2] = BM_Edge_Exist(verts[2],verts[3]);
edar[3] = BM_Edge_Exist(verts[3],verts[0]);
}else{
}
else {
edar[2] = BM_Edge_Exist(verts[2],verts[0]);
}
}
if(nodouble){
if(nodouble) {
/*check if face exists or overlaps*/
if(len == 4){
if(len == 4) {
overlap = BM_Exist_Face_Overlaps(bm, verts, len, &f);
}else{
}
else {
overlap = BM_Exist_Face_Overlaps(bm, verts, len, &f);
}
}
/*make new face*/
if((!f) && (!overlap)){
if((!f) && (!overlap)) {
if(!edar[0]) edar[0] = BM_Make_Edge(bm, verts[0], verts[1], NULL, 0);
if(!edar[1]) edar[1] = BM_Make_Edge(bm, verts[1], verts[2], NULL, 0);
if(len == 4){
if(len == 4) {
if(!edar[2]) edar[2] = BM_Make_Edge(bm, verts[2], verts[3], NULL, 0);
if(!edar[3]) edar[3] = BM_Make_Edge(bm, verts[3], verts[0], NULL, 0);
} else {

172
source/blender/bmesh/intern/bmesh_eulers.c
View File

@@ -142,12 +142,12 @@ BMEdge *bmesh_me(BMesh *bm, BMVert *v1, BMVert *v2)
#ifndef bmesh_FASTEULER
/*count valance of v1*/
if(v1->e){
if(v1->e) {
d1 = bmesh_disk_getpointer(v1->e,v1);
if(d1) valance1 = bmesh_cycle_length(d1);
else bmesh_error();
}
if(v2->e){
if(v2->e) {
d2 = bmesh_disk_getpointer(v2->e,v2);
if(d2) valance2 = bmesh_cycle_length(d2);
else bmesh_error();
@@ -225,13 +225,13 @@ BMFace *bmesh_mf(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **elist, int len)
diskbase = bmesh_disk_getpointer(v1->e, v1);
len = bmesh_cycle_length(diskbase);
for(a=0,curedge=v1->e;a<len;a++,curedge = bmesh_disk_nextedge(curedge,v1)){
for(a=0,curedge=v1->e;a<len;a++,curedge = bmesh_disk_nextedge(curedge,v1)) {
curedge->head.eflag1 = curedge->head.eflag2 = 0;
}
}
}
for(i=0;i<len;i++){
for(i=0;i<len;i++) {
elist[i]->head.eflag1 |= MF_CANDIDATE;
/*if elist[i] has a loop, count its radial length*/
@@ -243,7 +243,7 @@ BMFace *bmesh_mf(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **elist, int len)
Note that this does not gauruntee that face is a single closed loop. At best it gauruntees
that elist contains a finite number of seperate closed loops.
*/
// for(i=0; i<len; i++){
// for(i=0; i<len; i++) {
// edok = bmesh_disk_count_edgeflag(elist[i]->v1, MF_CANDIDATE, 0);
// if(edok != 2) return NULL;
// edok = bmesh_disk_count_edgeflag(elist[i]->v2, MF_CANDIDATE, 0);
@@ -255,7 +255,7 @@ BMFace *bmesh_mf(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **elist, int len)
tv = v1;
curvert = v2;
if(bm->vtarlen < len){
if(bm->vtarlen < len) {
if (bm->vtar) MEM_freeN(bm->vtar);
bm->vtar = MEM_callocN(sizeof(BMVert *)* len, "BM Vert pointer array");
bm->vtarlen = len;
@@ -271,7 +271,7 @@ BMFace *bmesh_mf(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **elist, int len)
edge, loop until we find TV. We know TV is reachable because of test we did earlier.
*/
done=0;
while(!done){
while(!done) {
/*add curvert to vlist*/
/*insert some error cheking here for overflows*/
i++;
@@ -283,7 +283,7 @@ BMFace *bmesh_mf(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **elist, int len)
/*find next edge and vert*/
curedge = bmesh_disk_next_edgeflag(curedge, curvert, MF_CANDIDATE, 0);
curvert = bmesh_edge_getothervert(curedge, curvert);
if(curvert == tv){
if(curvert == tv) {
curedge->head.eflag1 |= MF_VISITED;
done=1;
}
@@ -293,17 +293,17 @@ BMFace *bmesh_mf(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **elist, int len)
from sv, but that several unconnected loops were passed in via elist.
*/
cont=1;
// for(i=0; i<len; i++){
// for(i=0; i<len; i++) {
// if((elist[i]->head.eflag1 & MF_VISITED) == 0) cont = 0;
// }
/*if we get this far, its ok to allocate the face and add the loops*/
if(cont){
if(cont) {
BMLoop *l;
BMEdge *e;
f = bmesh_addpolylist(bm, NULL);
f->len = len;
for(i=0;i<len;i++){
for(i=0;i<len;i++) {
curvert = vlist[i];
l = bmesh_create_loop(bm,curvert,NULL,f,NULL);
if(!(f->loopbase)) f->lbase = l;
@@ -315,10 +315,10 @@ BMFace *bmesh_mf(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **elist, int len)
e = NULL;
if(l == f->loopbase) e = elist[0]; /*first edge*/
else{/*search elist for others*/
for(j=1; j<len; j++){
else {/*search elist for others*/
for(j=1; j<len; j++) {
edok = bmesh_verts_in_edge(l->v, ((l->next))->v, elist[j]);
if(edok){
if(edok) {
e = elist[j];
break;
}
@@ -333,7 +333,7 @@ BMFace *bmesh_mf(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **elist, int len)
/*Validation Loop cycle*/
edok = bmesh_cycle_validate(len, f->lbase);
if(!edok) bmesh_error();
for(i=0, l = f->loopbase; i<len; i++, l=((l->next))){
for(i=0, l = f->loopbase; i<len; i++, l=((l->next))) {
/*validate loop vert pointers*/
edok = bmesh_verts_in_edge(l->v, ((l->next))->v, l->e);
if(!edok) bmesh_error();
@@ -362,7 +362,7 @@ BMFace *bmesh_mf(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **elist, int len)
int bmesh_kv(BMesh *bm, BMVert *v)
{
if(v->e == NULL){
if(v->e == NULL) {
if (BM_TestHFlag(v, BM_SELECT)) bm->totvertsel--;
BLI_remlink(&(bm->verts), &(v->head));
@@ -388,7 +388,7 @@ int bmesh_ke(BMesh *bm, BMEdge *e)
int edok;
/*Make sure that no faces!*/
if(e->l == NULL){
if(e->l == NULL) {
bmesh_disk_remove_edge(e, e->v1);
bmesh_disk_remove_edge(e, e->v2);
@@ -431,7 +431,7 @@ int bmesh_kf(BMesh *bm, BMFace *bply)
bmesh_radial_remove_loop(curloop, curloop->e);
/*now deallocate the editloops*/
for(i=0; i < len; i++){
for(i=0; i < len; i++) {
newbase = ((bply->lbase->next));
oldbase = bply->lbase;
bmesh_cycle_remove(oldbase, oldbase);
@@ -506,12 +506,12 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
if(!edok) bmesh_error();
/*Split the radial cycle if present*/
if(e->l){
if(e->l) {
BMLoop *nl,*l;
BMNode *radEBase=NULL, *radNEBase=NULL;
int radlen = bmesh_cycle_length(&(e->l->radial));
/*Take the next loop. Remove it from radial. Split it. Append to appropriate radials.*/
while(e->l){
while(e->l) {
l=e->l;
l->f->len++;
bmesh_radial_remove_loop(l,e);
@@ -524,18 +524,18 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
nl->v = nv;
/*assign the correct edge to the correct loop*/
if(bmesh_verts_in_edge(nl->v, ((nl->next))->v, e)){
if(bmesh_verts_in_edge(nl->v, ((nl->next))->v, e)) {
nl->e = e;
l->e = ne;
/*append l into ne's rad cycle*/
if(!radNEBase){
if(!radNEBase) {
radNEBase = &(l->radial);
radNEBase->next = NULL;
radNEBase->prev = NULL;
}
if(!radEBase){
if(!radEBase) {
radEBase = &(nl->radial);
radEBase->next = NULL;
radEBase->prev = NULL;
@@ -545,16 +545,16 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
bmesh_cycle_append(radNEBase,&(l->radial));
}
else if(bmesh_verts_in_edge(nl->v,((nl->next))->v,ne)){
else if(bmesh_verts_in_edge(nl->v,((nl->next))->v,ne)) {
nl->e = ne;
l->e = e;
if(!radNEBase){
if(!radNEBase) {
radNEBase = &(nl->radial);
radNEBase->next = NULL;
radNEBase->prev = NULL;
}
if(!radEBase){
if(!radEBase) {
radEBase = &(l->radial);
radEBase->next = NULL;
radEBase->prev = NULL;
@@ -575,7 +575,7 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
if(!edok) bmesh_error();
/*verify loop->v and loop->next->v pointers for e*/
for(i=0,l=e->l; i < radlen; i++, l = l->radial_next){
for(i=0,l=e->l; i < radlen; i++, l = l->radial_next) {
if(!(l->e == e)) bmesh_error();
if(!(l->radial.data == l)) bmesh_error();
if( ((l->prev))->e != ne && ((l->next))->e != ne) bmesh_error();
@@ -588,7 +588,7 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
if(!edok) bmesh_error();
}
/*verify loop->v and loop->next->v pointers for ne*/
for(i=0,l=ne->l; i < radlen; i++, l = l->radial_next){
for(i=0,l=ne->l; i < radlen; i++, l = l->radial_next) {
if(!(l->e == ne)) bmesh_error();
if(!(l->radial.data == l)) bmesh_error();
if( ((l->prev))->e != e && ((l->next))->e != e) bmesh_error();
@@ -646,7 +646,7 @@ BMFace *bmesh_sfme(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, BMLoop **rl)
/*verify that v1 and v2 are in face.*/
len = bmesh_cycle_length(f->lbase);
for(i = 0, curloop = f->loopbase; i < len; i++, curloop = ((curloop->next)) ){
for(i = 0, curloop = f->loopbase; i < len; i++, curloop = ((curloop->next)) ) {
if(curloop->v == v1) v1loop = curloop;
else if(curloop->v == v2) v2loop = curloop;
}
@@ -740,14 +740,14 @@ int bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv)
diskbase = bmesh_disk_getpointer(kv->e, kv);
len = bmesh_cycle_length(diskbase);
if(len == 2){
if(len == 2) {
oe = bmesh_disk_nextedge(ke, kv);
tv = bmesh_edge_getothervert(ke, kv);
ov = bmesh_edge_getothervert(oe, kv);
halt = bmesh_verts_in_edge(kv, tv, oe); //check for double edges
if(halt) return 0;
else{
else {
/*For verification later, count valance of ov and tv*/
diskbase = bmesh_disk_getpointer(ov->e, ov);
@@ -767,10 +767,10 @@ int bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv)
/*deal with radial cycle of ke*/
if(ke->l){
if(ke->l) {
/*first step, fix the neighboring loops of all loops in ke's radial cycle*/
radlen = bmesh_cycle_length(&(ke->l->radial));
for(i=0,killoop = ke->l; i<radlen; i++, killoop = bmesh_radial_nextloop(killoop)){
for(i=0,killoop = ke->l; i<radlen; i++, killoop = bmesh_radial_nextloop(killoop)) {
/*relink loops and fix vertex pointer*/
killoop->next->prev = killoop->prev;
killoop->prev->next = killoop->next;
@@ -784,20 +784,20 @@ int bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv)
killoop = ke->l;
radlen = bmesh_cycle_length(&(ke->l->radial));
/*make sure we have enough room in bm->lpar*/
if(bm->lparlen < radlen){
if(bm->lparlen < radlen) {
MEM_freeN(bm->lpar);
bm->lpar = MEM_callocN(sizeof(BMLoop *)* radlen, "BM Loop pointer array");
bm->lparlen = bm->lparlen * radlen;
}
/*this should be wrapped into a bme_free_radial function to be used by bmesh_KF as well...*/
i=0;
while(i<radlen){
while(i<radlen) {
bm->lpar[i] = killoop;
killoop = killoop->radial_next;
i++;
}
i=0;
while(i<radlen){
while(i<radlen) {
bmesh_free_loop(bm,bm->lpar[i]);
i++;
}
@@ -816,7 +816,7 @@ int bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv)
if(!edok) bmesh_error();
/*Validate loop cycle of all faces attached to oe*/
for(i=0,nextl = oe->l; i<radlen; i++, nextl = bmesh_radial_nextloop(nextl)){
for(i=0,nextl = oe->l; i<radlen; i++, nextl = bmesh_radial_nextloop(nextl)) {
edok = bmesh_cycle_validate(nextl->f->len,nextl->f->lbase);
if(!edok) bmesh_error();
}
@@ -854,13 +854,13 @@ int bmesh_loop_reverse(BMesh *bm, BMFace *f)
int i, j, edok, len = 0;
len = bmesh_cycle_length(l);
if(bm->edarlen < len){
if(bm->edarlen < len) {
MEM_freeN(bm->edar);
bm->edar = MEM_callocN(sizeof(BMEdge *)* len, "BM Edge pointer array");
bm->edarlen = len;
}
for(i=0, curloop = l; i< len; i++, curloop= ((curloop->next)) ){
for(i=0, curloop = l; i< len; i++, curloop= ((curloop->next)) ) {
curloop->e->head.eflag1 = 0;
curloop->e->head.eflag2 = bmesh_cycle_length(&curloop->radial);
bmesh_radial_remove_loop(curloop, curloop->e);
@@ -870,7 +870,7 @@ int bmesh_loop_reverse(BMesh *bm, BMFace *f)
}
/*actually reverse the loop. This belongs in bmesh_cycle_reverse!*/
for(i=0, curloop = l; i < len; i++){
for(i=0, curloop = l; i < len; i++) {
oldnext = ((curloop->next));
oldprev = ((curloop->prev));
curloop->next = (BMHeader*)oldprev;
@@ -878,17 +878,17 @@ int bmesh_loop_reverse(BMesh *bm, BMFace *f)
curloop = oldnext;
}
if(len == 2){ //two edged face
if(len == 2) { //two edged face
//do some verification here!
l->e = bm->edar[1];
((l->next))->e = bm->edar[0];
}
else{
for(i=0, curloop = l; i < len; i++, curloop = ((curloop->next)) ){
else {
for(i=0, curloop = l; i < len; i++, curloop = ((curloop->next)) ) {
edok = 0;
for(j=0; j < len; j++){
for(j=0; j < len; j++) {
edok = bmesh_verts_in_edge(curloop->v, ((curloop->next))->v, bm->edar[j]);
if(edok){
if(edok) {
curloop->e = bm->edar[j];
break;
}
@@ -899,9 +899,9 @@ int bmesh_loop_reverse(BMesh *bm, BMFace *f)
for(i=0, curloop = l; i < len; i++, curloop = curloop->next ) bmesh_radial_append(curloop->e, curloop);
/*validate radial*/
for(i=0, curloop = l; i < len; i++, curloop = ((curloop->next)) ){
for(i=0, curloop = l; i < len; i++, curloop = ((curloop->next)) ) {
edok = bmesh_cycle_validate(curloop->e->head.eflag2, &(curloop->radial));
if(!edok){
if(!edok) {
bmesh_error();
}
}
@@ -952,14 +952,14 @@ BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e)
/*verify that e is in both f1 and f2*/
f1len = bmesh_cycle_length(f1->lbase);
f2len = bmesh_cycle_length(f2->lbase);
for(i=0, curloop = f1->loopbase; i < f1len; i++, curloop = ((curloop->next)) ){
if(curloop->e == e){
for(i=0, curloop = f1->loopbase; i < f1len; i++, curloop = ((curloop->next)) ) {
if(curloop->e == e) {
f1loop = curloop;
break;
}
}
for(i=0, curloop = f2->loopbase; i < f2len; i++, curloop = ((curloop->next)) ){
if(curloop->e==e){
for(i=0, curloop = f2->loopbase; i < f2len; i++, curloop = ((curloop->next)) ) {
if(curloop->e==e) {
f2loop = curloop;
break;
}
@@ -990,21 +990,21 @@ BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e)
for(i=0, curloop = f1->loopbase; i < f1len; i++, curloop = ((curloop->next)) ) curloop->v->head.eflag1 = 0;
for(i=0, curloop = f2->loopbase; i < f2len; i++, curloop = ((curloop->next)) ) curloop->v->head.eflag1 = 0;
for(i=0, curloop = f1->loopbase; i < f1len; i++, curloop = ((curloop->next)) ){
for(i=0, curloop = f1->loopbase; i < f1len; i++, curloop = ((curloop->next)) ) {
if(curloop != f1loop)
curloop->v->head.eflag1++;
}
for(i=0, curloop = f2->loopbase; i < f2len; i++, curloop = ((curloop->next)) ){
for(i=0, curloop = f2->loopbase; i < f2len; i++, curloop = ((curloop->next)) ) {
if(curloop != f2loop)
curloop->v->head.eflag1++;
}
for(i=0, curloop = f1->loopbase; i < f1len; i++, curloop = ((curloop->next)) ){
for(i=0, curloop = f1->loopbase; i < f1len; i++, curloop = ((curloop->next)) ) {
if(curloop->v->head.eflag1 > 1)
return NULL;
}
for(i=0, curloop = f2->loopbase; i < f2len; i++, curloop = ((curloop->next)) ){
for(i=0, curloop = f2->loopbase; i < f2len; i++, curloop = ((curloop->next)) ) {
if(curloop->v->head.eflag1 > 1)
return NULL;
}
@@ -1079,21 +1079,21 @@ BMVert *bmesh_urmv(BMesh *bm, BMFace *sf, BMVert *sv)
/*first verify no wire edges on sv*/
curedge = sv->e;
do{
do {
if(curedge->l == NULL)
return NULL;
curedge = bmesh_disk_nextedge(curedge, sv);
}while(curedge != sv->e);
} while(curedge != sv->e);
/*next verify that sv is in sf*/
l = sf->loopbase;
do{
if(l->v == sv){
do {
if(l->v == sv) {
sl = l;
break;
}
l = (l->next);
}while(l != sf->lbase);
} while(l != sf->lbase);
if(sl == NULL)
return NULL;
@@ -1102,16 +1102,16 @@ BMVert *bmesh_urmv(BMesh *bm, BMFace *sf, BMVert *sv)
sv->head.eflag1 = 0;
curedge = sv->e;
do{
do {
curedge->head.eflag1 = 0;
l = curedge->l;
do{
do {
l->head.eflag1 = 0;
l->f->head.eflag1 = 0;
l = bmesh_radial_nextloop(l);
}while(l != curedge->l);
} while(l != curedge->l);
curedge = bmesh_disk_nextedge(curedge, sv);
}while(curedge != sv->e);
} while(curedge != sv->e);
/*search through face disk and flag elements as we go.*/
/*Note, test this to make sure that it works correct on
@@ -1120,45 +1120,45 @@ BMVert *bmesh_urmv(BMesh *bm, BMFace *sf, BMVert *sv)
l = sl;
l->e->head.eflag1 |= URMV_VISIT;
l->f->head.eflag1 |= URMV_VISIT;
do{
do {
if(l->v == sv)
l = bmesh_radial_nextloop((l->prev));
else
l = bmesh_radial_nextloop((l->next));
l->e->head.eflag1 |= URMV_VISIT;
l->f->head.eflag1 |= URMV_VISIT;
}while(l != sl && (bmesh_cycle_length(&(l->radial)) > 1) );
} while(l != sl && (bmesh_cycle_length(&(l->radial)) > 1) );
/*Verify that all visited edges are at least 1 or 2 manifold*/
curedge = sv->e;
do{
do {
if(curedge->head.eflag1 && (bmesh_cycle_length(&(curedge->l->radial)) > 2) )
return NULL;
curedge = bmesh_disk_nextedge(curedge, sv);
}while(curedge != sv->e);
} while(curedge != sv->e);
/*allocate temp storage - we overallocate here instead of trying to be clever*/
maxedges = 0;
maxloops = 0;
curedge = sv->e;
do{
if(curedge->l){
do {
if(curedge->l) {
l = curedge->l;
do{
do {
maxloops += l->f->len;
l = bmesh_radial_nextloop(l);
}while(l != curedge->l);
} while(l != curedge->l);
}
maxedges+= 1;
curedge = bmesh_disk_nextedge(curedge,sv);
}while(curedge != sv->e);
} while(curedge != sv->e);
if(bm->edarlen < maxedges){
if(bm->edarlen < maxedges) {
MEM_freeN(bm->edar);
bm->edar = MEM_callocN(sizeof(BMEdge *) * maxedges, "BM Edge pointer array");
bm->edarlen = maxedges;
}
if(bm->lparlen < maxloops){
if(bm->lparlen < maxloops) {
MEM_freeN(bm->lpar);
bm->lpar = MEM_callocN(sizeof(BMLoop *) * maxloops, "BM Loop pointer array");
bm->lparlen = maxloops;
@@ -1166,36 +1166,36 @@ BMVert *bmesh_urmv(BMesh *bm, BMFace *sf, BMVert *sv)
/*first get loops by looping around edges and loops around that edges faces*/
curedge = sv->e;
do{
if(curedge->l){
do {
if(curedge->l) {
l = curedge->l;
do{
if( (l->head.eflag1 & URMV_VISIT) && (!(l->head.eflag1 & URMV_VISIT2)) ){
do {
if( (l->head.eflag1 & URMV_VISIT) && (!(l->head.eflag1 & URMV_VISIT2)) ) {
bm->lpar[numloops] = l;
l->head.eflag1 |= URMV_VISIT2;
numloops++;
}
l = bmesh_radial_nextloop(l);
}while(l != curedge->l);
} while(l != curedge->l);
}
curedge = bmesh_disk_nextedge(curedge, sv);
}while(curedge != sv->e);
} while(curedge != sv->e);
/*now collect edges by looping around edges and looking at visited flags*/
curedge = sv->e;
do{
if(curedge->head.eflag1 & URMV_VISIT){
do {
if(curedge->head.eflag1 & URMV_VISIT) {
bm->edar[numedges] = curedge;
numedges++;
}
curedge = bmesh_disk_nextedge(curedge, sv);
}while(curedge != sv->e);
} while(curedge != sv->e);
/*make new vertex*/
nv = bmesh_addvertlist(bm, sv);
/*go through and relink edges*/
for(i = 0; i < numedges; i++){
for(i = 0; i < numedges; i++) {
curedge = bm->edar[i];
/*remove curedge from sv*/
bmesh_disk_remove_edge(curedge, sv);
@@ -1206,7 +1206,7 @@ BMVert *bmesh_urmv(BMesh *bm, BMFace *sf, BMVert *sv)
}
/*go through and relink loops*/
for(i = 0; i < numloops; i ++){
for(i = 0; i < numloops; i ++) {
l = bm->lpar[i];
if(l->v == sv)
l->v = nv;

13
source/blender/bmesh/intern/bmesh_interp.c
View File

@@ -102,12 +102,13 @@ void BM_Data_Facevert_Edgeinterp(BMesh *bm, BMVert *v1, BMVert *UNUSED(v2), BMVe
if(!e1->l) return;
l = e1->l;
do{
if(l->v == v1){
do {
if(l->v == v1) {
v1loop = l;
vloop = v1loop->next;
v2loop = vloop->next;
}else if(l->v == v){
}
else if(l->v == v) {
v1loop = l->next;
vloop = l;
v2loop = l->prev;
@@ -121,7 +122,7 @@ void BM_Data_Facevert_Edgeinterp(BMesh *bm, BMVert *v1, BMVert *UNUSED(v2), BMVe
CustomData_bmesh_interp(&bm->ldata, src,w, NULL, 2, vloop->head.data);
l = l->radial_next;
}while(l!=e1->l);
} while(l!=e1->l);
}
void BM_loops_to_corners(BMesh *bm, Mesh *me, int findex,
@@ -136,7 +137,7 @@ void BM_loops_to_corners(BMesh *bm, Mesh *me, int findex,
MLoopUV *mloopuv;
int i, j;
for(i=0; i < numTex; i++){
for(i=0; i < numTex; i++) {
texface = CustomData_get_n(&me->fdata, CD_MTFACE, findex, i);
texpoly = CustomData_bmesh_get_n(&bm->pdata, f->head.data, CD_MTEXPOLY, i);
@@ -158,7 +159,7 @@ void BM_loops_to_corners(BMesh *bm, Mesh *me, int findex,
}
for(i=0; i < numCol; i++){
for(i=0; i < numCol; i++) {
mcol = CustomData_get_n(&me->fdata, CD_MCOL, findex, i);
j = 0;

14
source/blender/bmesh/intern/bmesh_iterators.c
View File

@@ -167,7 +167,7 @@ void *bmiter__face_of_mesh_step(BMIter *iter)
void bmiter__edge_of_vert_begin(BMIter *iter)
{
init_iterator(iter);
if(iter->vdata->e){
if(iter->vdata->e) {
iter->firstedge = iter->vdata->e;
iter->nextedge = iter->vdata->e;
}
@@ -196,7 +196,7 @@ void bmiter__face_of_vert_begin(BMIter *iter)
iter->count = 0;
if(iter->vdata->e)
iter->count = bmesh_disk_count_facevert(iter->vdata);
if(iter->count){
if(iter->count) {
iter->firstedge = bmesh_disk_find_first_faceedge(iter->vdata->e, iter->vdata);
iter->nextedge = iter->firstedge;
iter->firstloop = bmesh_radial_find_first_facevert(iter->firstedge->l, iter->vdata);
@@ -210,7 +210,7 @@ void *bmiter__face_of_vert_step(BMIter *iter)
if(iter->count && iter->nextloop) {
iter->count--;
iter->nextloop = bmesh_radial_find_next_facevert(iter->nextloop, iter->vdata);
if(iter->nextloop == iter->firstloop){
if(iter->nextloop == iter->firstloop) {
iter->nextedge = bmesh_disk_find_next_faceedge(iter->nextedge, iter->vdata);
iter->firstloop = bmesh_radial_find_first_facevert(iter->nextedge->l, iter->vdata);
iter->nextloop = iter->firstloop;
@@ -236,7 +236,7 @@ void bmiter__loop_of_vert_begin(BMIter *iter)
iter->count = 0;
if(iter->vdata->e)
iter->count = bmesh_disk_count_facevert(iter->vdata);
if(iter->count){
if(iter->count) {
iter->firstedge = bmesh_disk_find_first_faceedge(iter->vdata->e, iter->vdata);
iter->nextedge = iter->firstedge;
iter->firstloop = bmesh_radial_find_first_facevert(iter->firstedge->l, iter->vdata);
@@ -247,10 +247,10 @@ void *bmiter__loop_of_vert_step(BMIter *iter)
{
BMLoop *current = iter->nextloop;
if(iter->count){
if(iter->count) {
iter->count--;
iter->nextloop = bmesh_radial_find_next_facevert(iter->nextloop, iter->vdata);
if(iter->nextloop == iter->firstloop){
if(iter->nextloop == iter->firstloop) {
iter->nextedge = bmesh_disk_find_next_faceedge(iter->nextedge, iter->vdata);
iter->firstloop = bmesh_radial_find_first_facevert(iter->nextedge->l, iter->vdata);
iter->nextloop = iter->firstloop;
@@ -327,7 +327,7 @@ void bmiter__face_of_edge_begin(BMIter *iter)
{
init_iterator(iter);
if(iter->edata->l){
if(iter->edata->l) {
iter->firstloop = iter->edata->l;
iter->nextloop = iter->edata->l;
}

2
source/blender/bmesh/intern/bmesh_iterators_inline.c
View File

@@ -63,7 +63,7 @@ BM_INLINE void *BMIter_New(BMIter *iter, BMesh *bm, const char itype, void *data
iter->bm = bm;
/* inlining optimizes out this switch when called with the defined type */
switch(itype){
switch(itype) {
case BM_VERTS_OF_MESH:
iter->begin = bmiter__vert_of_mesh_begin;
iter->step = bmiter__vert_of_mesh_step;

46
source/blender/bmesh/intern/bmesh_marking.c
View File

@@ -100,7 +100,7 @@ void BM_SelectMode_Flush(BMesh *bm)
for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm ); f; f= BMIter_Step(&faces)) {
totsel = 0;
l=(BMLoop*) bm_firstfaceloop(f);
do{
do {
if(BM_TestHFlag(l->v, BM_SELECT))
totsel++;
l = l->next;
@@ -118,11 +118,11 @@ void BM_SelectMode_Flush(BMesh *bm)
for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm ); f; f= BMIter_Step(&faces)) {
totsel = 0;
l = bm_firstfaceloop(f);
do{
do {
if(BM_TestHFlag(&(l->e->head), BM_SELECT))
totsel++;
l = l->next;
}while(l!=bm_firstfaceloop(f));
} while(l!=bm_firstfaceloop(f));
if(totsel == f->len && !BM_TestHFlag(f, BM_HIDDEN)) {
BM_SetHFlag(f, BM_SELECT);
@@ -183,36 +183,36 @@ void BM_Select_Edge(BMesh *bm, BMEdge *e, int select)
return;
}
if(select){
if(select) {
if (!BM_TestHFlag(e, BM_SELECT)) bm->totedgesel += 1;
BM_SetHFlag(&(e->head), BM_SELECT);
BM_Select(bm, e->v1, TRUE);
BM_Select(bm, e->v2, TRUE);
}else{
}
else {
if (BM_TestHFlag(e, BM_SELECT)) bm->totedgesel -= 1;
BM_ClearHFlag(&(e->head), BM_SELECT);
if(
bm->selectmode == SCE_SELECT_EDGE ||
bm->selectmode == SCE_SELECT_FACE ||
bm->selectmode == (SCE_SELECT_EDGE | SCE_SELECT_FACE)){
if ( bm->selectmode == SCE_SELECT_EDGE ||
bm->selectmode == SCE_SELECT_FACE ||
bm->selectmode == (SCE_SELECT_EDGE | SCE_SELECT_FACE))
{
BMIter iter;
BMVert *verts[2] = {e->v1, e->v2};
BMEdge *e2;
int i;
for(i = 0; i < 2; i++){
for(i = 0; i < 2; i++) {
int deselect = 1;
for(e2 = BMIter_New(&iter, bm, BM_EDGES_OF_VERT, verts[i]);
e2; e2 = BMIter_Step(&iter)){
if(e2 == e){
for(e2 = BMIter_New(&iter, bm, BM_EDGES_OF_VERT, verts[i]); e2; e2 = BMIter_Step(&iter)) {
if(e2 == e) {
continue;
}
if (BM_TestHFlag(e2, BM_SELECT)){
if (BM_TestHFlag(e2, BM_SELECT)) {
deselect = 0;
break;
}
@@ -246,18 +246,18 @@ void BM_Select_Face(BMesh *bm, BMFace *f, int select)
return;
}
if(select){
if(select) {
if (!BM_TestHFlag(f, BM_SELECT)) bm->totfacesel += 1;
BM_SetHFlag(&(f->head), BM_SELECT);
l=(BMLoop*) bm_firstfaceloop(f);
do{
do {
BM_Select_Vert(bm, l->v, TRUE);
BM_Select_Edge(bm, l->e, TRUE);
l = l->next;
}while(l != bm_firstfaceloop(f));
} while(l != bm_firstfaceloop(f));
}
else{
else {
BMIter liter;
BMLoop *l;
@@ -407,7 +407,7 @@ BMFace *BM_get_actFace(BMesh *bm, int sloppy)
/* Find the latest non-hidden face from the BMEditSelection */
ese = bm->selected.last;
for (; ese; ese=ese->prev){
for (; ese; ese=ese->prev) {
if(ese->htype == BM_FACE) {
f= (BMFace *)ese->data;
@@ -588,7 +588,7 @@ static int BM_check_selection(BMesh *bm, void *data)
{
BMEditSelection *ese;
for(ese = bm->selected.first; ese; ese = ese->next){
for(ese = bm->selected.first; ese; ese = ese->next) {
if(ese->data == data) return 1;
}
@@ -598,8 +598,8 @@ static int BM_check_selection(BMesh *bm, void *data)
void BM_remove_selection(BMesh *bm, void *data)
{
BMEditSelection *ese;
for(ese=bm->selected.first; ese; ese = ese->next){
if(ese->data == data){
for(ese=bm->selected.first; ese; ese = ese->next) {
if(ese->data == data) {
BLI_freelinkN(&(bm->selected),ese);
break;
}
@@ -615,7 +615,7 @@ void BM_clear_selection_history(BMesh *bm)
void BM_store_selection(BMesh *bm, void *data)
{
BMEditSelection *ese;
if(!BM_check_selection(bm, data)){
if(!BM_check_selection(bm, data)) {
ese = (BMEditSelection*) MEM_callocN( sizeof(BMEditSelection), "BMEdit Selection");
ese->htype = ((BMHeader*)data)->htype;
ese->data = data;

2
source/blender/bmesh/intern/bmesh_mesh.c
View File

@@ -120,7 +120,7 @@ void BM_Free_Mesh_Data(BMesh *bm)
for(v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm ); v; v = BMIter_Step(&verts)) CustomData_bmesh_free_block( &(bm->vdata), &(v->head.data) );
for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm ); e; e = BMIter_Step(&edges)) CustomData_bmesh_free_block( &(bm->edata), &(e->head.data) );
for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm ); f; f = BMIter_Step(&faces)){
for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm ); f; f = BMIter_Step(&faces)) {
CustomData_bmesh_free_block( &(bm->pdata), &(f->head.data) );
for(l = BMIter_New(&loops, bm, BM_LOOPS_OF_FACE, f ); l; l = BMIter_Step(&loops)) CustomData_bmesh_free_block( &(bm->ldata), &(l->head.data) );
}

39
source/blender/bmesh/intern/bmesh_mods.c
View File

@@ -107,18 +107,18 @@ int BM_Dissolve_Disk(BMesh *bm, BMVert *v)
return 0;
}
if(v->e){
if(v->e) {
/*v->e we keep, what else?*/
e = v->e;
do{
do {
e = bmesh_disk_nextedge(e,v);
if(!(BM_Edge_Share_Faces(e, v->e))){
if(!(BM_Edge_Share_Faces(e, v->e))) {
keepedge = e;
baseedge = v->e;
break;
}
len++;
}while(e != v->e);
} while(e != v->e);
}
/*this code for handling 2 and 3-valence verts
@@ -135,7 +135,8 @@ int BM_Dissolve_Disk(BMesh *bm, BMVert *v)
return 0;
}
return 1;
} else if (keepedge == NULL && len == 2) {
}
else if (keepedge == NULL && len == 2) {
/*collapse the vertex*/
e = BM_Collapse_Vert_Faces(bm, v->e, v, 1.0);
@@ -154,13 +155,13 @@ int BM_Dissolve_Disk(BMesh *bm, BMVert *v)
return 1;
}
if(keepedge){
if(keepedge) {
int done = 0;
while(!done){
while(!done) {
done = 1;
e = v->e;
do{
do {
f = NULL;
len = bmesh_radial_length(e->l);
if(len == 2 && (e!=baseedge) && (e!=keepedge)) {
@@ -171,12 +172,12 @@ int BM_Dissolve_Disk(BMesh *bm, BMVert *v)
if (!f) return 0;
}
if(f){
if(f) {
done = 0;
break;
}
e = bmesh_disk_nextedge(e, v);
}while(e != v->e);
} while(e != v->e);
}
/*collapse the vertex*/
@@ -208,9 +209,9 @@ void BM_Dissolve_Disk(BMesh *bm, BMVert *v)
BMIter iter;
int done, len;
if(v->e){
if(v->e) {
done = 0;
while(!done){
while(!done) {
done = 1;
/*loop the edges looking for an edge to dissolve*/
@@ -218,12 +219,12 @@ void BM_Dissolve_Disk(BMesh *bm, BMVert *v)
e = BMIter_Step(&iter)) {
f = NULL;
len = bmesh_cycle_length(&(e->l->radial));
if(len == 2){
if(len == 2) {
f = BM_Join_TwoFaces(bm,e->l->f,((BMLoop*)
(e->l->radial_next))->f,
e);
}
if(f){
if(f) {
done = 0;
break;
}
@@ -258,16 +259,16 @@ BMFace *BM_Join_TwoFaces(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e)
BMFace *faces[2] = {f1, f2};
jed = e;
if(!jed){
if(!jed) {
/*search for an edge that has both these faces in its radial cycle*/
l1 = bm_firstfaceloop(f1);
do{
do {
if(l1->radial_next->f == f2 ) {
jed = l1->e;
break;
}
l1 = l1->next;
}while(l1!=bm_firstfaceloop(f1));
} while(l1!=bm_firstfaceloop(f1));
}
if (!jed) {
@@ -423,7 +424,7 @@ BMEdge* BM_Collapse_Vert_Faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac)
if (ke->l) {
l = ke->l;
do{
do {
if(l->v == tv && l->next->v == kv) {
tvloop = l;
kvloop = l->next;
@@ -634,7 +635,7 @@ BMVert *BM_Split_Edge_Multi(BMesh *bm, BMEdge *e, int numcuts)
float percent;
BMVert *nv = NULL;
for(i=0; i < numcuts; i++){
for(i=0; i < numcuts; i++) {
percent = 1.0f / (float)(numcuts + 1 - i);
nv = BM_Split_Edge(bm, e->v2, e, NULL, percent);
}

36
source/blender/bmesh/intern/bmesh_newcore.c
View File

@@ -634,7 +634,7 @@ static int bmesh_loop_reverse_loop(BMesh *bm, BMFace *f, BMLoopList *lst)
}
/*actually reverse the loop.*/
for(i=0, curloop = l; i < len; i++){
for(i=0, curloop = l; i < len; i++) {
oldnext = curloop->next;
oldprev = curloop->prev;
curloop->next = oldprev;
@@ -660,17 +660,17 @@ static int bmesh_loop_reverse_loop(BMesh *bm, BMFace *f, BMLoopList *lst)
}
}
if(len == 2){ //two edged face
//do some verification here!
if(len == 2) { /* two edged face */
/* do some verification here! */
l->e = edar[1];
l->next->e = edar[0];
}
else{
else {
for(i=0, curloop = l; i < len; i++, curloop = curloop->next) {
edok = 0;
for(j=0; j < len; j++){
for(j=0; j < len; j++) {
edok = bmesh_verts_in_edge(curloop->v, curloop->next->v, edar[j]);
if(edok){
if(edok) {
curloop->e = edar[j];
break;
}
@@ -1232,7 +1232,7 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
bmesh_radial_append(nl->e, nl);
bmesh_radial_append(l->e, l);
}
else if(bmesh_verts_in_edge(nl->v, nl->next->v, ne)){
else if(bmesh_verts_in_edge(nl->v, nl->next->v, ne)) {
nl->e = ne;
l->e = e;
@@ -1260,7 +1260,7 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
if(!edok) bmesh_error();
/*verify loop->v and loop->next->v pointers for e*/
for(i=0,l=e->l; i < radlen; i++, l = l->radial_next){
for(i=0,l=e->l; i < radlen; i++, l = l->radial_next) {
if(!(l->e == e)) bmesh_error();
//if(!(l->radial_next == l)) bmesh_error();
if(l->prev->e != ne && l->next->e != ne) bmesh_error();
@@ -1276,7 +1276,7 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
BM_CHECK_ELEMENT(bm, l->f);
}
/*verify loop->v and loop->next->v pointers for ne*/
for(i=0,l=ne->l; i < radlen; i++, l = l->radial_next){
for(i=0,l=ne->l; i < radlen; i++, l = l->radial_next) {
if(!(l->e == ne)) bmesh_error();
//if(!(l->radial_next == l)) bmesh_error();
if( l->prev->e != e && l->next->e != e) bmesh_error();
@@ -1345,14 +1345,16 @@ int bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv)
if(bmesh_vert_in_edge(ke,kv) == 0) return 0;
len = bmesh_disk_count(kv);
if(len == 2){
if(len == 2) {
oe = bmesh_disk_nextedge(ke, kv);
tv = bmesh_edge_getothervert(ke, kv);
ov = bmesh_edge_getothervert(oe, kv);
halt = bmesh_verts_in_edge(kv, tv, oe); /*check for double edges*/
if(halt) return 0;
else{
if(halt) {
return 0;
}
else {
/*For verification later, count valence of ov and tv*/
valence1 = bmesh_disk_count(ov);
valence2 = bmesh_disk_count(tv);
@@ -1368,9 +1370,9 @@ int bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv)
/*deal with radial cycle of ke*/
radlen = bmesh_radial_length(ke->l);
if(ke->l){
if(ke->l) {
/*first step, fix the neighboring loops of all loops in ke's radial cycle*/
for(i=0,killoop = ke->l; i<radlen; i++, killoop = bmesh_radial_nextloop(killoop)){
for(i=0,killoop = ke->l; i<radlen; i++, killoop = bmesh_radial_nextloop(killoop)) {
/*relink loops and fix vertex pointer*/
if( killoop->next->v == kv ) killoop->next->v = tv;
@@ -1422,7 +1424,7 @@ int bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv)
if(!edok) bmesh_error();
/*Validate loop cycle of all faces attached to oe*/
for(i=0,l = oe->l; i<radlen; i++, l = bmesh_radial_nextloop(l)){
for(i=0,l = oe->l; i<radlen; i++, l = bmesh_radial_nextloop(l)) {
if(l->e != oe) bmesh_error();
edok = bmesh_verts_in_edge(l->v, l->next->v, oe);
if(!edok) bmesh_error();
@@ -1488,13 +1490,13 @@ BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e)
f1len = f1->len;
f2len = f2->len;
BM_ITER(curloop, &iter, bm, BM_LOOPS_OF_FACE, f1) {
if(curloop->e == e){
if(curloop->e == e) {
f1loop = curloop;
break;
}
}
BM_ITER(curloop, &iter, bm, BM_LOOPS_OF_FACE, f2) {
if(curloop->e == e){
if(curloop->e == e) {
f2loop = curloop;
break;
}

34
source/blender/bmesh/intern/bmesh_operators.c
View File

@@ -265,7 +265,7 @@ void BMO_CopySlot(BMOperator *source_op, BMOperator *dest_op, const char *src, c
/*do buffer copy*/
dest_slot->data.buf = NULL;
dest_slot->len = source_slot->len;
if(dest_slot->len){
if(dest_slot->len) {
dest_slot->data.buf = BLI_memarena_alloc(dest_op->arena, BMOP_OPSLOT_TYPEINFO[dest_slot->slottype] * dest_slot->len);
memcpy(dest_slot->data.buf, source_slot->data.buf, BMOP_OPSLOT_TYPEINFO[dest_slot->slottype] * dest_slot->len);
}
@@ -438,20 +438,20 @@ int BMO_CountFlag(BMesh *bm, int flag, const char htype)
BMHeader *e;
int count = 0;
if(htype & BM_VERT){
for(e = BMIter_New(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BMIter_Step(&elements)){
if(htype & BM_VERT) {
for(e = BMIter_New(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
if(BMO_TestFlag(bm, e, flag))
count++;
}
}
if(htype & BM_EDGE){
for(e = BMIter_New(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&elements)){
if(htype & BM_EDGE) {
for(e = BMIter_New(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
if(BMO_TestFlag(bm, e, flag))
count++;
}
}
if(htype & BM_FACE){
for(e = BMIter_New(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BMIter_Step(&elements)){
if(htype & BM_FACE) {
for(e = BMIter_New(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
if(BMO_TestFlag(bm, e, flag))
count++;
}
@@ -587,7 +587,7 @@ static void BMO_All_To_Slot(BMesh *bm, BMOperator *op, const char *slotname, con
if (htype & BM_EDGE) totelement += bm->totedge;
if (htype & BM_FACE) totelement += bm->totface;
if(totelement){
if(totelement) {
alloc_slot_buffer(op, slotname, totelement);
if (htype & BM_VERT) {
@@ -632,7 +632,7 @@ void BMO_HeaderFlag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname,
totelement = BM_CountFlag(bm, htype, hflag, 1);
if(totelement){
if(totelement) {
alloc_slot_buffer(op, slotname, totelement);
if (htype & BM_VERT) {
@@ -681,12 +681,12 @@ void BMO_Flag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname,
BMOpSlot *output = BMO_GetSlot(op, slotname);
int totelement = BMO_CountFlag(bm, flag, htype), i=0;
if(totelement){
if(totelement) {
alloc_slot_buffer(op, slotname, totelement);
if (htype & BM_VERT) {
for (e = BMIter_New(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
if(BMO_TestFlag(bm, e, flag)){
if(BMO_TestFlag(bm, e, flag)) {
((BMHeader**)output->data.p)[i] = e;
i++;
}
@@ -695,7 +695,7 @@ void BMO_Flag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname,
if (htype & BM_EDGE) {
for (e = BMIter_New(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
if(BMO_TestFlag(bm, e, flag)){
if(BMO_TestFlag(bm, e, flag)) {
((BMHeader**)output->data.p)[i] = e;
i++;
}
@@ -704,7 +704,7 @@ void BMO_Flag_To_Slot(BMesh *bm, BMOperator *op, const char *slotname,
if (htype & BM_FACE) {
for (e = BMIter_New(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BMIter_Step(&elements)) {
if(BMO_TestFlag(bm, e, flag)){
if(BMO_TestFlag(bm, e, flag)) {
((BMHeader**)output->data.p)[i] = e;
i++;
}
@@ -774,7 +774,7 @@ int BMO_Vert_CountEdgeFlags(BMesh *bm, BMVert *v, int toolflag)
const int len= bmesh_disk_count(v);
int i;
for(i = 0, curedge=v->e; i<len; i++){
for(i = 0, curedge=v->e; i<len; i++) {
if (BMO_TestFlag(bm, curedge, toolflag))
count++;
curedge = bmesh_disk_nextedge(curedge, v);
@@ -942,13 +942,13 @@ static void clear_flag_layer(BMesh *bm)
BMIter faces;
/*now go through and memcpy all the flags*/
for(v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts)){
for(v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts)) {
memset(v->head.flags+(bm->totflags-1), 0, sizeof(BMFlagLayer));
}
for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)){
for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) {
memset(e->head.flags+(bm->totflags-1), 0, sizeof(BMFlagLayer));
}
for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)){
for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)) {
memset(f->head.flags+(bm->totflags-1), 0, sizeof(BMFlagLayer));
}
}

26
source/blender/bmesh/intern/bmesh_polygon.c
View File

@@ -117,7 +117,7 @@ static void compute_poly_normal(float normal[3], float (*verts)[3], int nverts)
/*this fixes some weird numerical error*/
add_v3_fl(verts[0], 0.0001f);
for(i = 0; i < nverts; i++){
for(i = 0; i < nverts; i++) {
copy_v3_v3(u, verts[i]);
copy_v3_v3(v, verts[(i+1) % nverts]);
copy_v3_v3(w, verts[(i+2) % nverts]);
@@ -200,7 +200,7 @@ static int compute_poly_center(float center[3], float *r_area, float (*verts)[3]
i = nverts-1;
j = 0;
while(j < nverts){
while(j < nverts) {
ai = verts[i][0] * verts[j][1] - verts[j][0] * verts[i][1];
atmp += ai;
xtmp += (verts[j][0] + verts[i][0]) * ai;
@@ -212,7 +212,7 @@ static int compute_poly_center(float center[3], float *r_area, float (*verts)[3]
if(r_area)
*r_area = atmp / 2.0f;
if (atmp != 0){
if (atmp != 0) {
center[0] = xtmp / (3.0f * atmp);
center[1] = xtmp / (3.0f * atmp);
return 1;
@@ -300,7 +300,7 @@ void compute_poly_plane(float (*verts)[3], int nverts)
zero_v3(avgn);
zero_v3(avgc);
for(i = 0; i < nverts; i++){
for(i = 0; i < nverts; i++) {
v1 = verts[i];
v2 = verts[(i+1) % nverts];
v3 = verts[(i+2) % nverts];
@@ -323,7 +323,7 @@ void compute_poly_plane(float (*verts)[3], int nverts)
normalize_v3(avgn);
}
for(i = 0; i < nverts; i++){
for(i = 0; i < nverts; i++) {
v1 = verts[i];
mag = dot_v3v3(v1, avgn);
madd_v3_v3fl(v1, avgn, -mag);
@@ -500,14 +500,14 @@ void bmesh_update_face_normal(BMesh *bm, BMFace *f, float (*projectverts)[3])
compute_poly_normal(f->no, projectverts, f->len);
}
else if(f->len == 3){
else if(f->len == 3) {
BMVert *v1, *v2, *v3;
v1 = bm_firstfaceloop(f)->v;
v2 = bm_firstfaceloop(f)->next->v;
v3 = bm_firstfaceloop(f)->next->next->v;
normal_tri_v3( f->no,v1->co, v2->co, v3->co);
}
else if(f->len == 4){
else if(f->len == 4) {
BMVert *v1, *v2, *v3, *v4;
v1 = bm_firstfaceloop(f)->v;
v2 = bm_firstfaceloop(f)->next->v;
@@ -515,7 +515,7 @@ void bmesh_update_face_normal(BMesh *bm, BMFace *f, float (*projectverts)[3])
v4 = bm_firstfaceloop(f)->prev->v;
normal_quad_v3( f->no,v1->co, v2->co, v3->co, v4->co);
}
else{ /*horrible, two sided face!*/
else { /*horrible, two sided face!*/
zero_v3(f->no);
}
@@ -767,12 +767,12 @@ void BM_Triangulate_Face(BMesh *bm, BMFace *f, float (*projectverts)[3],
/*copy vertex coordinates to vertspace array*/
i = 0;
l = bm_firstfaceloop(f);
do{
do {
copy_v3_v3(projectverts[i], l->v->co);
BM_SetIndex(l->v, i); /* set dirty! */
i++;
l = l->next;
}while(l != bm_firstfaceloop(f));
} while(l != bm_firstfaceloop(f));
bm->elem_index_dirty |= BM_VERT; /* see above */
@@ -789,7 +789,7 @@ void BM_Triangulate_Face(BMesh *bm, BMFace *f, float (*projectverts)[3],
}
done = 0;
while(!done && f->len > 3){
while(!done && f->len > 3) {
done = 1;
l = find_ear(bm, f, projectverts, nvert);
if(l) {
@@ -821,9 +821,9 @@ void BM_Triangulate_Face(BMesh *bm, BMFace *f, float (*projectverts)[3],
}
}
if (f->len > 3){
if (f->len > 3) {
l = bm_firstfaceloop(f);
while (l->f->len > 3){
while (l->f->len > 3) {
nextloop = l->next->next;
f = BM_Split_Face(bm, l->f, l->v, nextloop->v,
&newl, NULL);

44
source/blender/bmesh/intern/bmesh_queries.c
View File

@@ -165,11 +165,11 @@ int BM_Edge_In_Face(BMFace *f, BMEdge *e)
BMLoop *l;
l = bm_firstfaceloop(f);
do{
do {
if(l->e == e) return 1;
l = l->next;
}while(l != bm_firstfaceloop(f));
} while(l != bm_firstfaceloop(f));
return 0;
}
@@ -222,12 +222,12 @@ int BM_Edge_FaceCount(BMEdge *e)
int count = 0;
BMLoop *curloop = NULL;
if(e->l){
if(e->l) {
curloop = e->l;
do{
do {
count++;
curloop = bmesh_radial_nextloop(curloop);
}while(curloop != e->l);
} while(curloop != e->l);
}
return count;
@@ -252,12 +252,12 @@ int BM_Vert_FaceCount(BMVert *v)
#if 0 //this code isn't working
BMEdge *curedge = NULL;
if(v->e){
if(v->e) {
curedge = v->e;
do{
do {
if(curedge->l) count += BM_Edge_FaceCount(curedge);
curedge = bmesh_disk_nextedge(curedge,v);
}while(curedge != v->e);
} while(curedge != v->e);
}
return count;
#endif
@@ -280,10 +280,10 @@ int BM_Wire_Vert(BMesh *UNUSED(bm), BMVert *v)
if(!(v->e)) return 0;
curedge = v->e;
do{
do {
if(curedge->l) return 0;
curedge = bmesh_disk_nextedge(curedge, v);
}while(curedge != v->e);
} while(curedge != v->e);
return 1;
}
@@ -430,10 +430,10 @@ int BM_Face_Share_Edges(BMFace *f1, BMFace *f2)
int count = 0;
l = bm_firstfaceloop(f1);
do{
do {
if(bmesh_radial_find_face(l->e,f2)) count++;
l = l->next;
}while(l != bm_firstfaceloop(f1));
} while(l != bm_firstfaceloop(f1));
return count;
}
@@ -451,15 +451,15 @@ int BM_Edge_Share_Faces(BMEdge *e1, BMEdge *e2)
BMLoop *l;
BMFace *f;
if(e1->l && e2->l){
if(e1->l && e2->l) {
l = e1->l;
do{
do {
f = l->f;
if(bmesh_radial_find_face(e2,f)){
if(bmesh_radial_find_face(e2,f)) {
return 1;
}
l = l->radial_next;
}while(l != e1->l);
} while(l != e1->l);
}
return 0;
}
@@ -552,11 +552,11 @@ int BM_Exist_Face_Overlaps(BMesh *bm, BMVert **varr, int len, BMFace **overlapfa
if (overlapface) *overlapface = NULL;
for(i=0; i < len; i++){
for(i=0; i < len; i++) {
f = BMIter_New(&vertfaces, bm, BM_FACES_OF_VERT, varr[i] );
while(f){
while(f) {
amount = BM_Verts_In_Face(bm, f, varr, len);
if(amount >= len){
if(amount >= len) {
if (overlapface) *overlapface = f;
return 1;
}
@@ -588,11 +588,11 @@ int BM_Face_Exists(BMesh *bm, BMVert **varr, int len, BMFace **existface)
if (existface) *existface = NULL;
for(i=0; i < len; i++){
for(i=0; i < len; i++) {
f = BMIter_New(&vertfaces, bm, BM_FACES_OF_VERT, varr[i] );
while(f){
while(f) {
amount = BM_Verts_In_Face(bm, f, varr, len);
if(amount == len && amount == f->len){
if(amount == len && amount == f->len) {
if (existface) *existface = f;
return 1;
}

92
source/blender/bmesh/intern/bmesh_structure.c
View File

@@ -63,7 +63,7 @@ int bmesh_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e)
return 0;
}
BMVert *bmesh_edge_getothervert(BMEdge *e, BMVert *v){
BMVert *bmesh_edge_getothervert(BMEdge *e, BMVert *v) {
if(e->v1 == v) return e->v2;
else if(e->v2 == v) return e->v1;
return NULL;
@@ -71,12 +71,12 @@ BMVert *bmesh_edge_getothervert(BMEdge *e, BMVert *v){
int bmesh_edge_swapverts(BMEdge *e, BMVert *orig, BMVert *newv)
{
if(e->v1 == orig){
if(e->v1 == orig) {
e->v1 = newv;
e->dlink1.next = e->dlink1.prev = NULL;
return 1;
}
else if(e->v2 == orig){
else if(e->v2 == orig) {
e->v2 = newv;
e->dlink2.next = e->dlink2.prev = NULL;
return 1;
@@ -301,10 +301,10 @@ int bmesh_disk_count_facevert(BMVert *v)
/*first, loop around edges*/
curedge = v->e;
do{
do {
if(curedge->l) count += bmesh_radial_count_facevert(curedge->l, v);
curedge = bmesh_disk_nextedge(curedge, v);
}while(curedge != v->e);
} while(curedge != v->e);
return count;
}
@@ -313,10 +313,10 @@ struct BMEdge *bmesh_disk_find_first_faceedge(struct BMEdge *e, struct BMVert *v
{
BMEdge *searchedge = NULL;
searchedge = e;
do{
do {
if(searchedge->l && bmesh_radial_count_facevert(searchedge->l,v)) return searchedge;
searchedge = bmesh_disk_nextedge(searchedge,v);
}while(searchedge != e);
} while(searchedge != e);
return NULL;
}
@@ -325,10 +325,10 @@ struct BMEdge *bmesh_disk_find_next_faceedge(struct BMEdge *e, struct BMVert *v)
{
BMEdge *searchedge = NULL;
searchedge = bmesh_disk_nextedge(e,v);
do{
do {
if(searchedge->l && bmesh_radial_count_facevert(searchedge->l,v)) return searchedge;
searchedge = bmesh_disk_nextedge(searchedge,v);
}while(searchedge !=e);
} while(searchedge !=e);
return e;
}
@@ -414,10 +414,10 @@ BMLoop *bmesh_radial_find_first_facevert(BMLoop *l, BMVert *v)
{
BMLoop *curloop;
curloop = l;
do{
do {
if(curloop->v == v) return curloop;
curloop = bmesh_radial_nextloop(curloop);
}while(curloop != l);
} while(curloop != l);
return NULL;
}
@@ -425,10 +425,10 @@ BMLoop *bmesh_radial_find_next_facevert(BMLoop *l, BMVert *v)
{
BMLoop *curloop;
curloop = bmesh_radial_nextloop(l);
do{
do {
if(curloop->v == v) return curloop;
curloop = bmesh_radial_nextloop(curloop);
}while(curloop !=l);
} while(curloop !=l);
return l;
}
@@ -512,10 +512,10 @@ int bmesh_radial_count_facevert(BMLoop *l, BMVert *v)
BMLoop *curloop;
int count = 0;
curloop = l;
do{
do {
if(curloop->v == v) count++;
curloop = bmesh_radial_nextloop(curloop);
}while(curloop != l);
} while(curloop != l);
return count;
}
@@ -555,13 +555,13 @@ void bmesh_cycle_append(void *h, void *nt)
head = (BMNode*)h;
newtail = (BMNode*)nt;
if(head->next == NULL){
if(head->next == NULL) {
head->next = newtail;
head->prev = newtail;
newtail->next = head;
newtail->prev = head;
}
else{
else {
oldtail = head->prev;
oldtail->next = newtail;
newtail->next = head;
@@ -619,14 +619,14 @@ int bmesh_cycle_remove(void *h, void *remn)
remnode = (BMNode*)remn;
len = bmesh_cycle_length(h);
if(len == 1 && head == remnode){
if(len == 1 && head == remnode) {
head->next = NULL;
head->prev = NULL;
return 1;
}
else{
for(i=0, curnode = head; i < len; curnode = curnode->next){
if(curnode == remnode){
else {
for(i=0, curnode = head; i < len; curnode = curnode->next) {
if(curnode == remnode) {
remnode->prev->next = remnode->next;
remnode->next->prev = remnode->prev;
/*zero out remnode pointers, important!*/
@@ -681,7 +681,7 @@ int bmesh_cycle_validate(int len, void *h)
BMEdge *bmesh_disk_nextedge(BMEdge *e, BMVert *v)
{
if(bmesh_vert_in_edge(e, v)){
if(bmesh_vert_in_edge(e, v)) {
if(e->v1 == v) return e->d1.next->data;
else if(e->v2 == v) return e->d2.next->data;
}
@@ -721,7 +721,7 @@ int bmesh_disk_append_edge(BMEdge *e, BMVert *v)
if(bmesh_vert_in_edge(e, v) == 0) return 0; /*check to make sure v is in e*/
/*check for loose vert first*/
if(v->e == NULL){
if(v->e == NULL) {
v->e = e;
base = tail = bmesh_disk_getpointer(e, v);
bmesh_cycle_append(base, tail); /*circular reference is ok!*/
@@ -785,12 +785,12 @@ BMEdge *bmesh_disk_next_edgeflag(BMEdge *e, BMVert *v, int eflag, int tflag)
if(eflag && tflag) return NULL;
ok = bmesh_vert_in_edge(e,v);
if(ok){
if(ok) {
diskbase = bmesh_disk_getpointer(e, v);
len = bmesh_cycle_length(diskbase);
curedge = bmesh_disk_nextedge(e,v);
while(curedge != e){
if(eflag){
while(curedge != e) {
if(eflag) {
if(curedge->head.eflag1 == eflag) return curedge;
}
curedge = bmesh_disk_nextedge(curedge, v);
@@ -815,13 +815,13 @@ int bmesh_disk_count_edgeflag(BMVert *v, int eflag, int tflag)
BMEdge *curedge;
int i, len=0, count=0;
if(v->e){
if(v->e) {
if(eflag && tflag) return 0; /*tflag and eflag are reserved for different functions!*/
diskbase = bmesh_disk_getpointer(v->e, v);
len = bmesh_cycle_length(diskbase);
for(i = 0, curedge=v->e; i<len; i++){
if(eflag){
for(i = 0, curedge=v->e; i<len; i++) {
if(eflag) {
if(curedge->head.eflag1 == eflag) count++;
}
curedge = bmesh_disk_nextedge(curedge, v);
@@ -837,11 +837,11 @@ int bmesh_disk_hasedge(BMVert *v, BMEdge *e)
BMEdge *curedge;
int i, len=0;
if(v->e){
if(v->e) {
diskbase = bmesh_disk_getpointer(v->e,v);
len = bmesh_cycle_length(diskbase);
for(i = 0, curedge=v->e; i<len; i++){
for(i = 0, curedge=v->e; i<len; i++) {
if(curedge == e) return 1;
else curedge=bmesh_disk_nextedge(curedge, v);
}
@@ -855,11 +855,11 @@ BMEdge *bmesh_disk_existedge(BMVert *v1, BMVert *v2)
BMEdge *curedge;
int i, len=0;
if(v1->e){
if(v1->e) {
diskbase = bmesh_disk_getpointer(v1->e,v1);
len = bmesh_cycle_length(diskbase);
for(i=0,curedge=v1->e;i<len;i++,curedge = bmesh_disk_nextedge(curedge,v1)){
for(i=0,curedge=v1->e;i<len;i++,curedge = bmesh_disk_nextedge(curedge,v1)) {
if(bmesh_verts_in_edge(v1,v2,curedge)) return curedge;
}
}
@@ -902,7 +902,7 @@ int bmesh_radial_find_face(BMEdge *e,BMFace *f)
int i, len;
len = bmesh_cycle_length(&(e->l->radial));
for(i = 0, curloop = e->l; i < len; i++, curloop = curloop->radial_next){
for(i = 0, curloop = e->l; i < len; i++, curloop = curloop->radial_next) {
if(curloop->f == f) return 1;
}
return 0;
@@ -922,10 +922,10 @@ int bmesh_radial_count_facevert(BMLoop *l, BMVert *v)
BMLoop *curloop;
int count = 0;
curloop = l;
do{
do {
if(curloop->v == v) count++;
curloop = bmesh_radial_nextloop(curloop);
}while(curloop != l);
} while(curloop != l);
return count;
}
@@ -950,10 +950,10 @@ int bmesh_disk_count_facevert(BMVert *v)
/*first, loop around edges*/
curedge = v->e;
do{
do {
if(curedge->l) count += bmesh_radial_count_facevert(curedge->l, v);
curedge = bmesh_disk_nextedge(curedge, v);
}while(curedge != v->e);
} while(curedge != v->e);
return count;
}
@@ -969,10 +969,10 @@ BMLoop *bmesh_radial_find_first_facevert(BMLoop *l, BMVert *v)
{
BMLoop *curloop;
curloop = l;
do{
do {
if(curloop->v == v) return curloop;
curloop = bmesh_radial_nextloop(curloop);
}while(curloop != l);
} while(curloop != l);
return NULL;
}
@@ -980,10 +980,10 @@ BMLoop *bmesh_radial_find_next_facevert(BMLoop *l, BMVert *v)
{
BMLoop *curloop;
curloop = bmesh_radial_nextloop(l);
do{
do {
if(curloop->v == v) return curloop;
curloop = bmesh_radial_nextloop(curloop);
}while(curloop !=l);
} while(curloop !=l);
return l;
}
@@ -1003,10 +1003,10 @@ BMEdge *bmesh_disk_find_first_faceedge(BMEdge *e, BMVert *v)
{
BMEdge *searchedge = NULL;
searchedge = e;
do{
do {
if(searchedge->l && bmesh_radial_count_facevert(searchedge->l,v)) return searchedge;
searchedge = bmesh_disk_nextedge(searchedge,v);
}while(searchedge != e);
} while(searchedge != e);
return NULL;
}
@@ -1015,10 +1015,10 @@ BMEdge *bmesh_disk_find_next_faceedge(BMEdge *e, BMVert *v)
{
BMEdge *searchedge = NULL;
searchedge = bmesh_disk_nextedge(e,v);
do{
do {
if(searchedge->l && bmesh_radial_count_facevert(searchedge->l,v)) return searchedge;
searchedge = bmesh_disk_nextedge(searchedge,v);
}while(searchedge !=e);
} while(searchedge !=e);
return e;
}

6
source/blender/bmesh/intern/bmesh_to_editmesh.c
View File

@@ -77,7 +77,7 @@ static void loops_to_editmesh_corners(BMesh *bm, CustomData *facedata, void *fac
MLoopCol *mloopcol;
MLoopUV *mloopuv;
for(i=0; i < numTex; i++){
for(i=0; i < numTex; i++) {
texface = CustomData_em_get_n(facedata, face_block, CD_MTFACE, i);
texpoly = CustomData_bmesh_get_n(&bm->pdata, f->head.data, CD_MTEXPOLY, i);
@@ -100,7 +100,7 @@ static void loops_to_editmesh_corners(BMesh *bm, CustomData *facedata, void *fac
}
for(i=0; i < numCol; i++){
for(i=0; i < numCol; i++) {
mcol = CustomData_em_get_n(facedata, face_block, CD_MCOL, i);
j = 0;
l = f->loopbase;
@@ -158,7 +158,7 @@ static EditEdge *bmeshedge_to_editedge(BMesh *bm, EditMesh *em, BMEdge *e, EditV
{
EditEdge *eed = NULL;
if(!(findedgelist(em, evlist[e->v1->head.eflag1], evlist[e->v2->head.eflag1]))){
if(!(findedgelist(em, evlist[e->v1->head.eflag1], evlist[e->v2->head.eflag1]))) {
eed= addedgelist(em, evlist[e->v1->head.eflag1], evlist[e->v2->head.eflag1], NULL);
bmeshedge_to_editedge_internal(bm, em, e, eed);
}

2
source/blender/bmesh/intern/bmesh_walkers.c
View File

@@ -182,7 +182,7 @@ void *BMW_walk(BMWalker *walker)
{
void *current = NULL;
while(BMW_currentstate(walker)){
while(BMW_currentstate(walker)) {
current = walker->step(walker);
if(current) return current;
}

6
source/blender/bmesh/intern/bmesh_walkers_impl.c
View File

@@ -149,7 +149,7 @@ static void *shellWalker_step(BMWalker *walker)
/*find the next edge whose other vertex has not been visited*/
curedge = shellWalk.curedge;
do{
do {
if (!BLI_ghash_haskey(walker->visithash, curedge)) {
if(!walker->restrictflag || (walker->restrictflag &&
BMO_TestFlag(walker->bm, curedge, walker->restrictflag)))
@@ -169,7 +169,7 @@ static void *shellWalker_step(BMWalker *walker)
}
}
curedge = bmesh_disk_nextedge(curedge, shellWalk.base);
}while(curedge != shellWalk.curedge);
} while(curedge != shellWalk.curedge);
return shellWalk.curedge;
}
@@ -297,7 +297,7 @@ static void *islandboundWalker_step(BMWalker *walker)
l = bmesh_radial_nextloop(l);
f = l->f;
e = l->e;
if(walker->mask_face && !BMO_TestFlag(walker->bm, f, walker->mask_face)){
if(walker->mask_face && !BMO_TestFlag(walker->bm, f, walker->mask_face)) {
l = l->radial_next;
break;
}

35
source/blender/bmesh/intern/editmesh_to_bmesh.c
View File

@@ -80,7 +80,7 @@ static void editmesh_corners_to_loops(BMesh *bm, CustomData *facedata, void *fac
MLoopUV *mloopuv;
BMIter iter;
for(i=0; i < numTex; i++){
for(i=0; i < numTex; i++) {
texface = CustomData_em_get_n(facedata, face_block, CD_MTFACE, i);
texpoly = CustomData_bmesh_get_n(&bm->pdata, f->head.data, CD_MTEXPOLY, i);
@@ -98,7 +98,7 @@ static void editmesh_corners_to_loops(BMesh *bm, CustomData *facedata, void *fac
}
}
for(i=0; i < numCol; i++){
for(i=0; i < numCol; i++) {
mcol = CustomData_em_get_n(facedata, face_block, CD_MCOL, i);
for (j=0, l=BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, f); l; j++, l=BMIter_Step(&iter)) {
mloopcol = CustomData_bmesh_get_n(&bm->ldata, l->head.data, CD_MLOOPCOL, i);
@@ -194,10 +194,11 @@ static BMFace *editface_to_BMFace(BMesh *bm, BMOperator *op, EditMesh *em, EditF
edar[0] = BM_Make_Edge(bm, efa->v1->tmp.p, efa->v2->tmp.p, NULL, 1);
edar[1] = BM_Make_Edge(bm, efa->v2->tmp.p, efa->v3->tmp.p, NULL, 1);
if(efa->v4){
if(efa->v4) {
edar[2] = BM_Make_Edge(bm, efa->v3->tmp.p, efa->v4->tmp.p, NULL, 1);
edar[3] = BM_Make_Edge(bm, efa->v4->tmp.p, efa->v1->tmp.p, NULL, 1);
}else{
}
else {
edar[2] = BM_Make_Edge(bm, efa->v3->tmp.p, efa->v1->tmp.p, NULL, 1);
}
@@ -282,7 +283,7 @@ static void fuse_fgon(BMesh *bm, BMFace *f)
sf = f;
done = 0;
while(!done){
while(!done) {
done = 1;
l = sf->loopbase;
do{
@@ -297,7 +298,7 @@ static void fuse_fgon(BMesh *bm, BMFace *f)
}
sf->head.flag |= act;
if(sf){
if(sf) {
done = 0;
break;
} else { /*we have to get out of here...*/
@@ -305,7 +306,7 @@ static void fuse_fgon(BMesh *bm, BMFace *f)
}
}
l = l->next;
}while(l != sf->loopbase);
} while(l != sf->loopbase);
}
}
@@ -331,12 +332,12 @@ static BM_fgonconvert(BMesh *bm, BMOperator *op, EditMesh *em, int numCol, int n
EM_fgon_flags(em);
/*zero out efa->tmp, we store fgon index here*/
for(efa = em->faces.first; efa; efa = efa->next){
for(efa = em->faces.first; efa; efa = efa->next) {
efa->tmp.l = 0;
amount++;
}
/*go through and give each editface an fgon index*/
for(efa = em->faces.first; efa; efa = efa->next){
for(efa = em->faces.first; efa; efa = efa->next) {
if(efa->e1->fgoni) efa->tmp.l = efa->e1->fgoni;
else if(efa->e2->fgoni) efa->tmp.l = efa->e2->fgoni;
else if(efa->e3->fgoni) efa->tmp.l = efa->e3->fgoni;
@@ -345,7 +346,7 @@ static BM_fgonconvert(BMesh *bm, BMOperator *op, EditMesh *em, int numCol, int n
sb= sortblock= MEM_mallocN(sizeof(fgonsort)* amount,"fgon sort block");
for(efa = em->faces.first; efa; efa=efa->next){
for(efa = em->faces.first; efa; efa=efa->next) {
sb->x = efa->tmp.l;
sb->efa = efa;
sb->done = 0;
@@ -356,9 +357,9 @@ static BM_fgonconvert(BMesh *bm, BMOperator *op, EditMesh *em, int numCol, int n
sb = sortblock;
for(a=0; a<amount; a++, sb++) {
if(sb->x && sb->done == 0){
if(sb->x && sb->done == 0) {
/*first pass: add in faces for this fgon*/
for(b=a, sb1 = sb; b<amount && sb1->x == sb->x; b++, sb1++){
for(b=a, sb1 = sb; b<amount && sb1->x == sb->x; b++, sb1++) {
efa = sb1->efa;
sb1->f = editface_to_BMFace(bm, op, em, efa, numCol, numTex);
sb1->done = 1;
@@ -383,7 +384,7 @@ static void tag_wire_edges(EditMesh *em)
EditFace *efa;
EditEdge *eed;
for(eed = em->edges.first; eed; eed = eed->next) eed->f1 = 1;
for(efa = em->faces.first; efa; efa = efa->next){
for(efa = em->faces.first; efa; efa = efa->next) {
efa->e1->f1 = 0;
efa->e2->f1 = 0;
efa->e3->f1 = 0;
@@ -444,7 +445,7 @@ BMesh *editmesh_to_bmesh_intern(EditMesh *em, BMesh *bm, BMOperator *op)
tag_wire_edges(em);
/*add verts*/
for(eve = em->verts.first; eve; eve = eve->next){
for(eve = em->verts.first; eve; eve = eve->next) {
v = editvert_to_BMVert(bm, op, em, eve);
eve->tmp.p = v;
}
@@ -452,17 +453,17 @@ BMesh *editmesh_to_bmesh_intern(EditMesh *em, BMesh *bm, BMOperator *op)
BM_fgonconvert(bm, op, em, numCol, numTex);
/*clean up any dangling fgon flags*/
for (e=BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL); e; e=BMIter_Step(&iter)){
for (e=BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL); e; e=BMIter_Step(&iter)) {
e->head.flag &= ~BM_FGON;
}
/*do quads + triangles*/
for(efa = em->faces.first; efa; efa = efa->next){
for(efa = em->faces.first; efa; efa = efa->next) {
if(!efa->tmp.l) editface_to_BMFace(bm, op, em, efa, numCol, numTex);
}
/*add wire edges*/
for(eed = em->edges.first; eed; eed = eed->next){
for(eed = em->edges.first; eed; eed = eed->next) {
if(eed->f1) editedge_to_BMEdge(bm, op, em, eed);
}
//BM_end_edit(bm, BM_CALC_NORM);

56
source/blender/bmesh/operators/bmesh_dupeops.c
View File

@@ -178,14 +178,14 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target)
ehash = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "bmesh dupeops e");
/*initialize edge pointer array*/
for(f = BMIter_New(&faces, source, BM_FACES_OF_MESH, source); f; f = BMIter_Step(&faces)){
for(f = BMIter_New(&faces, source, BM_FACES_OF_MESH, source); f; f = BMIter_Step(&faces)) {
if(f->len > maxlength) maxlength = f->len;
}
edar = MEM_callocN(sizeof(BMEdge*) * maxlength, "BM copy mesh edge pointer array");
vtar = MEM_callocN(sizeof(BMVert*) * maxlength, "BM copy mesh vert pointer array");
for(v = BMIter_New(&verts, source, BM_VERTS_OF_MESH, source); v; v = BMIter_Step(&verts)){
if(BMO_TestFlag(source, (BMHeader*)v, DUPE_INPUT) && (!BMO_TestFlag(source, (BMHeader*)v, DUPE_DONE))){
for(v = BMIter_New(&verts, source, BM_VERTS_OF_MESH, source); v; v = BMIter_Step(&verts)) {
if(BMO_TestFlag(source, (BMHeader*)v, DUPE_INPUT) && (!BMO_TestFlag(source, (BMHeader*)v, DUPE_DONE))) {
BMIter iter;
int iso = 1;
@@ -215,8 +215,8 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target)
}
/*now we dupe all the edges*/
for(e = BMIter_New(&edges, source, BM_EDGES_OF_MESH, source); e; e = BMIter_Step(&edges)){
if(BMO_TestFlag(source, (BMHeader*)e, DUPE_INPUT) && (!BMO_TestFlag(source, (BMHeader*)e, DUPE_DONE))){
for(e = BMIter_New(&edges, source, BM_EDGES_OF_MESH, source); e; e = BMIter_Step(&edges)) {
if(BMO_TestFlag(source, (BMHeader*)e, DUPE_INPUT) && (!BMO_TestFlag(source, (BMHeader*)e, DUPE_DONE))) {
/*make sure that verts are copied*/
if(!BMO_TestFlag(source, (BMHeader*)e->v1, DUPE_DONE)) {
copy_vertex(source, e->v1, target, vhash);
@@ -233,19 +233,19 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target)
}
/*first we dupe all flagged faces and their elements from source*/
for(f = BMIter_New(&faces, source, BM_FACES_OF_MESH, source); f; f= BMIter_Step(&faces)){
if(BMO_TestFlag(source, (BMHeader*)f, DUPE_INPUT)){
for(f = BMIter_New(&faces, source, BM_FACES_OF_MESH, source); f; f= BMIter_Step(&faces)) {
if(BMO_TestFlag(source, (BMHeader*)f, DUPE_INPUT)) {
/*vertex pass*/
for(v = BMIter_New(&verts, source, BM_VERTS_OF_FACE, f); v; v = BMIter_Step(&verts)){
if(!BMO_TestFlag(source, (BMHeader*)v, DUPE_DONE)){
for(v = BMIter_New(&verts, source, BM_VERTS_OF_FACE, f); v; v = BMIter_Step(&verts)) {
if(!BMO_TestFlag(source, (BMHeader*)v, DUPE_DONE)) {
copy_vertex(source,v, target, vhash);
BMO_SetFlag(source, (BMHeader*)v, DUPE_DONE);
}
}
/*edge pass*/
for(e = BMIter_New(&edges, source, BM_EDGES_OF_FACE, f); e; e = BMIter_Step(&edges)){
if(!BMO_TestFlag(source, (BMHeader*)e, DUPE_DONE)){
for(e = BMIter_New(&edges, source, BM_EDGES_OF_FACE, f); e; e = BMIter_Step(&edges)) {
if(!BMO_TestFlag(source, (BMHeader*)e, DUPE_DONE)) {
copy_edge(op, source, e, target, vhash, ehash);
BMO_SetFlag(source, (BMHeader*)e, DUPE_DONE);
}
@@ -438,7 +438,7 @@ static void delete_verts(BMesh *bm)
BMIter edges;
BMIter faces;
for(v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts)){
for(v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts)) {
if(BMO_TestFlag(bm, (BMHeader*)v, DEL_INPUT)) {
/*Visit edges*/
for(e = BMIter_New(&edges, bm, BM_EDGES_OF_VERT, v); e; e = BMIter_Step(&edges))
@@ -462,9 +462,9 @@ static void delete_edges(BMesh *bm)
BMIter edges;
BMIter faces;
for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)){
for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) {
if(BMO_TestFlag(bm, (BMHeader*)e, DEL_INPUT)) {
for(f = BMIter_New(&faces, bm, BM_FACES_OF_EDGE, e); f; f = BMIter_Step(&faces)){
for(f = BMIter_New(&faces, bm, BM_FACES_OF_EDGE, e); f; f = BMIter_Step(&faces)) {
BMO_SetFlag(bm, (BMHeader*)f, DEL_INPUT);
}
}
@@ -494,17 +494,17 @@ static void delete_context(BMesh *bm, int type)
BMIter faces;
if(type == DEL_VERTS) delete_verts(bm);
else if(type == DEL_EDGES){
else if(type == DEL_EDGES) {
/*flush down to verts*/
for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)){
if(BMO_TestFlag(bm, (BMHeader*)e, DEL_INPUT)){
for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) {
if(BMO_TestFlag(bm, (BMHeader*)e, DEL_INPUT)) {
BMO_SetFlag(bm, (BMHeader*)(e->v1), DEL_INPUT);
BMO_SetFlag(bm, (BMHeader*)(e->v2), DEL_INPUT);
}
}
delete_edges(bm);
/*remove loose vertices*/
for(v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts)){
for(v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts)) {
if(BMO_TestFlag(bm, (BMHeader*)v, DEL_INPUT) && (!(v->e)))
BMO_SetFlag(bm, (BMHeader*)v, DEL_WIREVERT);
}
@@ -516,10 +516,10 @@ static void delete_context(BMesh *bm, int type)
BM_remove_tagged_faces(bm, DEL_INPUT);
BM_remove_tagged_edges(bm, DEL_INPUT);
BM_remove_tagged_verts(bm, DEL_INPUT);
} else if(type == DEL_FACES){
} else if(type == DEL_FACES) {
/*go through and mark all edges and all verts of all faces for delete*/
for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)){
if(BMO_TestFlag(bm, (BMHeader*)f, DEL_INPUT)){
for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)) {
if(BMO_TestFlag(bm, (BMHeader*)f, DEL_INPUT)) {
for(e = BMIter_New(&edges, bm, BM_EDGES_OF_FACE, f); e; e = BMIter_Step(&edges))
BMO_SetFlag(bm, (BMHeader*)e, DEL_INPUT);
for(v = BMIter_New(&verts, bm, BM_VERTS_OF_FACE, f); v; v = BMIter_Step(&verts))
@@ -527,19 +527,19 @@ static void delete_context(BMesh *bm, int type)
}
}
/*now go through and mark all remaining faces all edges for keeping.*/
for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)){
if(!BMO_TestFlag(bm, (BMHeader*)f, DEL_INPUT)){
for(e = BMIter_New(&edges, bm, BM_EDGES_OF_FACE, f); e; e= BMIter_Step(&edges)){
for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)) {
if(!BMO_TestFlag(bm, (BMHeader*)f, DEL_INPUT)) {
for(e = BMIter_New(&edges, bm, BM_EDGES_OF_FACE, f); e; e= BMIter_Step(&edges)) {
BMO_ClearFlag(bm, (BMHeader*)e, DEL_INPUT);
}
for(v = BMIter_New(&verts, bm, BM_VERTS_OF_FACE, f); v; v= BMIter_Step(&verts)){
for(v = BMIter_New(&verts, bm, BM_VERTS_OF_FACE, f); v; v= BMIter_Step(&verts)) {
BMO_ClearFlag(bm, (BMHeader*)v, DEL_INPUT);
}
}
}
/*also mark all the vertices of remaining edges for keeping.*/
for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)){
if(!BMO_TestFlag(bm, (BMHeader*)e, DEL_INPUT)){
for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) {
if(!BMO_TestFlag(bm, (BMHeader*)e, DEL_INPUT)) {
BMO_ClearFlag(bm, (BMHeader*)e->v1, DEL_INPUT);
BMO_ClearFlag(bm, (BMHeader*)e->v2, DEL_INPUT);
}
@@ -552,7 +552,7 @@ static void delete_context(BMesh *bm, int type)
BM_remove_tagged_verts(bm, DEL_INPUT);
}
/*does this option even belong in here?*/
else if(type == DEL_ALL){
else if(type == DEL_ALL) {
for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces))
BMO_SetFlag(bm, (BMHeader*)f, DEL_INPUT);
for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges))

2
source/blender/bmesh/operators/connectops.c
View File

@@ -30,7 +30,7 @@ void connectverts_exec(BMesh *bm, BMOperator *op)
BMO_Flag_Buffer(bm, op, "verts", VERT_INPUT, BM_VERT);
for (f=BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL); f; f=BMIter_Step(&iter)){
for (f=BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL); f; f=BMIter_Step(&iter)) {
BLI_array_empty(loops);
BLI_array_empty(verts);

2
source/blender/bmesh/operators/dissolveops.c
View File

@@ -359,7 +359,7 @@ void dissolveverts_exec(BMesh *bm, BMOperator *op)
found3 = 1;
while (found3) {
found3 = 0;
for (f=BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL); f; f=BMIter_Step(&iter)){
for (f=BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL); f; f=BMIter_Step(&iter)) {
if (!BM_Validate_Face(bm, f, stderr)) {
printf("error.\n");
}

2
source/blender/bmesh/operators/extrudeops.c
View File

@@ -208,7 +208,7 @@ void extrude_edge_context_exec(BMesh *bm, BMOperator *op)
found = 0;
BM_ITER(e, &viter, bm, BM_EDGES_OF_VERT, v) {
if (!BMO_TestFlag(bm, e, EXT_INPUT) || !BMO_TestFlag(bm, e, EXT_DEL)){
if (!BMO_TestFlag(bm, e, EXT_INPUT) || !BMO_TestFlag(bm, e, EXT_DEL)) {
found = 1;
break;
}

2
source/blender/bmesh/operators/join_triangles.c
View File

@@ -147,7 +147,7 @@ static int compareFaceAttribs(BMesh *bm, BMEdge *e, int douvs, int dovcols)
/*compare faceedges for each face attribute. Additional per face attributes can be added later*/
/*do VCOLs*/
if(lcol1 && dovcols){
if(lcol1 && dovcols) {
char *cols[4] = {(char*)lcol1, (char*)lcol2, (char*)lcol3, (char*)lcol4};
int i;

24
source/blender/bmesh/operators/mesh_conv.c
View File

@@ -290,27 +290,27 @@ void mesh_to_bmesh_exec(BMesh *bm, BMOperator *op)
"Selection Conversion Face Pointer Array");
for(i = 0, vertex = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL);
vertex; i++, vertex = BMIter_Step(&iter)){
vertex; i++, vertex = BMIter_Step(&iter)) {
vertex_array[i] = vertex;
}
for(i = 0, edge = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL);
edge; i++, edge = BMIter_Step(&iter)){
edge; i++, edge = BMIter_Step(&iter)) {
edge_array[i] = edge;
}
for(i = 0, face = BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL);
face; i++, face = BMIter_Step(&iter)){
face; i++, face = BMIter_Step(&iter)) {
face_array[i] = face;
}
if(me->mselect) {
for(i = 0; i < me->totselect; i++){
if(me->mselect[i].type == ME_VSEL){
for(i = 0; i < me->totselect; i++) {
if(me->mselect[i].type == ME_VSEL) {
BM_store_selection(bm, vertex_array[me->mselect[i].index]);
}else if(me->mselect[i].type == ME_ESEL){
}else if(me->mselect[i].type == ME_ESEL) {
BM_store_selection(bm, edge_array[me->mselect[i].index]);
}else if(me->mselect[i].type == ME_FSEL){
}else if(me->mselect[i].type == ME_FSEL) {
BM_store_selection(bm, face_array[me->mselect[i].index]);
}
}
@@ -362,7 +362,7 @@ static void loops_to_corners(BMesh *bm, Mesh *me, int findex,
}
}
for(i=0; i < numCol; i++){
for(i=0; i < numCol; i++) {
mcol = CustomData_get_n(&me->fdata, CD_MCOL, findex, i);
for (j=0; j<3; j++) {
@@ -780,14 +780,14 @@ void bmesh_to_mesh_exec(BMesh *bm, BMOperator *op)
me->mselect = MEM_callocN(sizeof(MSelect) * me->totselect, "Mesh selection history");
for(i = 0, selected = bm->selected.first; selected; i++, selected = selected->next){
if(selected->htype == BM_VERT){
for(i = 0, selected = bm->selected.first; selected; i++, selected = selected->next) {
if(selected->htype == BM_VERT) {
me->mselect[i].type = ME_VSEL;
}else if(selected->htype == BM_EDGE){
}else if(selected->htype == BM_EDGE) {
me->mselect[i].type = ME_ESEL;
}else if(selected->htype == BM_FACE){
}else if(selected->htype == BM_FACE) {
me->mselect[i].type = ME_FSEL;
}

6
source/blender/bmesh/operators/removedoubles.c
View File

@@ -66,11 +66,11 @@ int remdoubles_face_overlaps(BMesh *bm, BMVert **varr,
if (overlapface) *overlapface = NULL;
for(i=0; i < len; i++){
for(i=0; i < len; i++) {
f = BMIter_New(&vertfaces, bm, BM_FACES_OF_VERT, varr[i] );
while(f){
while(f) {
amount = BM_Verts_In_Face(bm, f, varr, len);
if(amount >= len){
if(amount >= len) {
if (overlapface) *overlapface = f;
return 1;
}

32
source/blender/editors/mesh/bmesh_select.c
View File

@@ -382,7 +382,7 @@ static unsigned int findnearestvert__backbufIndextest(void *handle, unsigned int
*/
BMVert *EDBM_findnearestvert(ViewContext *vc, int *dist, short sel, short strict)
{
if(vc->v3d->drawtype>OB_WIRE && (vc->v3d->flag & V3D_ZBUF_SELECT)){
if(vc->v3d->drawtype>OB_WIRE && (vc->v3d->flag & V3D_ZBUF_SELECT)) {
int distance;
unsigned int index;
BMVert *eve;
@@ -908,9 +908,9 @@ static int loop_multiselect(bContext *C, wmOperator *op)
int totedgesel = 0;
for(eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL);
eed; eed = BMIter_Step(&iter)){
eed; eed = BMIter_Step(&iter)) {
if(BM_TestHFlag(eed, BM_SELECT)){
if(BM_TestHFlag(eed, BM_SELECT)) {
totedgesel++;
}
}
@@ -920,23 +920,23 @@ static int loop_multiselect(bContext *C, wmOperator *op)
edindex = 0;
for(eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL);
eed; eed = BMIter_Step(&iter)){
eed; eed = BMIter_Step(&iter)) {
if(BM_TestHFlag(eed, BM_SELECT)){
if(BM_TestHFlag(eed, BM_SELECT)) {
edarray[edindex] = eed;
edindex++;
}
}
if(looptype){
for(edindex = 0; edindex < totedgesel; edindex +=1){
if(looptype) {
for(edindex = 0; edindex < totedgesel; edindex +=1) {
eed = edarray[edindex];
walker_select(em, BMW_EDGERING, eed, 1);
}
EDBM_selectmode_flush(em);
}
else{
for(edindex = 0; edindex < totedgesel; edindex +=1){
for(edindex = 0; edindex < totedgesel; edindex +=1) {
eed = edarray[edindex];
walker_select(em, BMW_LOOP, eed, 1);
}
@@ -1477,7 +1477,7 @@ int mouse_mesh(bContext *C, const int mval[2], short extend)
EDBM_store_selection(vc.em, eve);
BM_Select(vc.em->bm, eve, TRUE);
}
else if(extend){
else if(extend) {
EDBM_remove_selection(vc.em, eve);
BM_Select(vc.em->bm, eve, FALSE);
}
@@ -1504,25 +1504,25 @@ static void EDBM_strip_selections(BMEditMesh *em)
{
BMEditSelection *ese, *nextese;
if(!(em->selectmode & SCE_SELECT_VERTEX)){
if(!(em->selectmode & SCE_SELECT_VERTEX)) {
ese = em->bm->selected.first;
while(ese){
while(ese) {
nextese = ese->next;
if(ese->htype == BM_VERT) BLI_freelinkN(&(em->bm->selected),ese);
ese = nextese;
}
}
if(!(em->selectmode & SCE_SELECT_EDGE)){
if(!(em->selectmode & SCE_SELECT_EDGE)) {
ese=em->bm->selected.first;
while(ese){
while(ese) {
nextese = ese->next;
if(ese->htype == BM_EDGE) BLI_freelinkN(&(em->bm->selected), ese);
ese = nextese;
}
}
if(!(em->selectmode & SCE_SELECT_FACE)){
if(!(em->selectmode & SCE_SELECT_FACE)) {
ese=em->bm->selected.first;
while(ese){
while(ese) {
nextese = ese->next;
if(ese->htype == BM_FACE) BLI_freelinkN(&(em->bm->selected), ese);
ese = nextese;
@@ -1620,7 +1620,7 @@ void EDBM_convertsel(BMEditMesh *em, short oldmode, short selectmode)
}
}
if(oldmode == SCE_SELECT_EDGE){
if(oldmode == SCE_SELECT_EDGE) {
if(selectmode == SCE_SELECT_FACE) {
BMIter liter;
BMLoop *l;

70
source/blender/editors/mesh/bmesh_tools.c
View File

@@ -2046,7 +2046,7 @@ static int merge_firstlast(BMEditMesh *em, int first, int uvmerge, wmOperator *w
BMEditSelection *ese;
/* do sanity check in mergemenu in edit.c ?*/
if(first == 0){
if(first == 0) {
ese = em->bm->selected.last;
mergevert= (BMVert*)ese->data;
}
@@ -2630,8 +2630,8 @@ static void shape_propagate(Object *obedit, BMEditMesh *em, wmOperator *op)
#if 0
//TAG Mesh Objects that share this data
for(base = scene->base.first; base; base = base->next){
if(base->object && base->object->data == me){
for(base = scene->base.first; base; base = base->next) {
if(base->object && base->object->data == me) {
base->object->recalc = OB_RECALC_DATA;
}
}
@@ -2987,9 +2987,9 @@ static float bm_seg_intersect(BMEdge *e, CutCurve *c, int len, char mode,
*isected = 0;
/*check for *exact* vertex intersection first*/
if(mode!=KNIFE_MULTICUT){
for (i=0; i<len; i++){
if (i>0){
if(mode!=KNIFE_MULTICUT) {
for (i=0; i<len; i++) {
if (i>0) {
x11=x12;
y11=y12;
}
@@ -3001,13 +3001,13 @@ static float bm_seg_intersect(BMEdge *e, CutCurve *c, int len, char mode,
y12=c[i].y;
/*test e->v1*/
if((x11 == x21 && y11 == y21) || (x12 == x21 && y12 == y21)){
if((x11 == x21 && y11 == y21) || (x12 == x21 && y12 == y21)) {
perc = 0;
*isected = 1;
return(perc);
}
/*test e->v2*/
else if((x11 == x22 && y11 == y22) || (x12 == x22 && y12 == y22)){
else if((x11 == x22 && y11 == y22) || (x12 == x22 && y12 == y22)) {
perc = 0;
*isected = 2;
return(perc);
@@ -3016,8 +3016,8 @@ static float bm_seg_intersect(BMEdge *e, CutCurve *c, int len, char mode,
}
/*now check for edge interesect (may produce vertex intersection as well)*/
for (i=0; i<len; i++){
if (i>0){
for (i=0; i<len; i++) {
if (i>0) {
x11=x12;
y11=y12;
}
@@ -3036,9 +3036,9 @@ static float bm_seg_intersect(BMEdge *e, CutCurve *c, int len, char mode,
if (i==0) lastdist=dist;
/* if dist changes sign, and intersect point in edge's Bound Box*/
if ((lastdist*dist)<=0){
if ((lastdist*dist)<=0) {
xdiff1=(x12-x11); /* Equation of line between last 2 points */
if (xdiff1){
if (xdiff1) {
m1=(y12-y11)/xdiff1;
b1= ((x12*y11)-(x11*y12))/xdiff1;
}
@@ -3052,7 +3052,7 @@ static float bm_seg_intersect(BMEdge *e, CutCurve *c, int len, char mode,
y2min=MIN2(y21,y22)-0.001;
/* Found an intersect, calc intersect point */
if (m1==m2){ /* co-incident lines */
if (m1==m2) { /* co-incident lines */
/* cut at 50% of overlap area*/
x1max=MAX2(x11, x12);
x1min=MIN2(x11, x12);
@@ -3062,11 +3062,11 @@ static float bm_seg_intersect(BMEdge *e, CutCurve *c, int len, char mode,
y1min=MIN2(y11, y12);
yi= (MIN2(y2max,y1max)+MAX2(y2min,y1min))/2.0;
}
else if (m2==MAXSLOPE){
else if (m2==MAXSLOPE) {
xi=x22;
yi=m1*x22+b1;
}
else if (m1==MAXSLOPE){
else if (m1==MAXSLOPE) {
xi=x12;
yi=m2*x12+b2;
}
@@ -3076,18 +3076,18 @@ static float bm_seg_intersect(BMEdge *e, CutCurve *c, int len, char mode,
}
/* Intersect inside bounding box of edge?*/
if ((xi>=x2min)&&(xi<=x2max)&&(yi<=y2max)&&(yi>=y2min)){
if ((xi>=x2min)&&(xi<=x2max)&&(yi<=y2max)&&(yi>=y2min)) {
/*test for vertex intersect that may be 'close enough'*/
if(mode!=KNIFE_MULTICUT){
if(xi <= (x21 + threshold) && xi >= (x21 - threshold)){
if(yi <= (y21 + threshold) && yi >= (y21 - threshold)){
if(mode!=KNIFE_MULTICUT) {
if(xi <= (x21 + threshold) && xi >= (x21 - threshold)) {
if(yi <= (y21 + threshold) && yi >= (y21 - threshold)) {
*isected = 1;
perc = 0;
break;
}
}
if(xi <= (x22 + threshold) && xi >= (x22 - threshold)){
if(yi <= (y22 + threshold) && yi >= (y22 - threshold)){
if(xi <= (x22 + threshold) && xi >= (x22 - threshold)) {
if(yi <= (y22 + threshold) && yi >= (y22 - threshold)) {
*isected = 2;
perc = 0;
break;
@@ -3149,7 +3149,7 @@ static int knife_cut_exec(bContext *C, wmOperator *op)
/*the floating point coordinates of verts in screen space will be stored in a hash table according to the vertices pointer*/
gh = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "knife cut exec");
for(bv=BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL);bv;bv=BMIter_Step(&iter)){
for(bv=BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL);bv;bv=BMIter_Step(&iter)) {
scr = MEM_mallocN(sizeof(float)*2, "Vertex Screen Coordinates");
copy_v3_v3(co, bv->co);
co[3]= 1.0;
@@ -3752,20 +3752,20 @@ static int screw_mesh_exec(bContext *C, wmOperator *op)
v1 = NULL;
v2 = NULL;
for(eve = BMIter_New(&iter, em->bm, BM_VERTS_OF_MESH, NULL);
eve; eve = BMIter_Step(&iter)){
eve; eve = BMIter_Step(&iter)) {
valence = 0;
for(eed = BMIter_New(&eiter, em->bm, BM_EDGES_OF_VERT, eve);
eed; eed = BMIter_Step(&eiter)){
eed; eed = BMIter_Step(&eiter)) {
if(BM_TestHFlag(eed, BM_SELECT)){
if(BM_TestHFlag(eed, BM_SELECT)) {
valence++;
}
}
if(valence == 1){
if(valence == 1) {
if(v1==NULL) v1 = eve;
else if(v2==NULL) v2= eve;
else {
@@ -3850,19 +3850,19 @@ static int select_by_number_vertices_exec(bContext *C, wmOperator *op)
int type = RNA_enum_get(op->ptr, "type");
for(efa = BMIter_New(&iter, em->bm, BM_FACES_OF_MESH, NULL);
efa; efa = BMIter_Step(&iter)){
efa; efa = BMIter_Step(&iter)) {
int select = 0;
if(type == 0 && efa->len < numverts){
if(type == 0 && efa->len < numverts) {
select = 1;
}else if(type == 1 && efa->len == numverts){
}else if(type == 1 && efa->len == numverts) {
select = 1;
}else if(type == 2 && efa->len > numverts){
}else if(type == 2 && efa->len > numverts) {
select = 1;
}
if(select){
if(select) {
BM_Select(em->bm, efa, TRUE);
}
}
@@ -3908,17 +3908,17 @@ static int select_loose_verts_exec(bContext *C, wmOperator *UNUSED(op))
BMIter iter;
for(eve = BMIter_New(&iter, em->bm, BM_VERTS_OF_MESH, NULL);
eve; eve = BMIter_Step(&iter)){
eve; eve = BMIter_Step(&iter)) {
if(!eve->e){
if(!eve->e) {
BM_Select(em->bm, eve, TRUE);
}
}
for(eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL);
eed; eed = BMIter_Step(&iter)){
eed; eed = BMIter_Step(&iter)) {
if(!eed->l){
if(!eed->l) {
BM_Select(em->bm, eed, TRUE);
}
}