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

forgot to remove the old function

Browse Source
This commit is contained in:
Joseph Eagar
2011-04-11 01:40:12 +00:00
parent 53a85a8edf
commit 0ce2c5a385
1 changed files with 0 additions and 327 deletions
Download Patch File Download Diff File Expand all files Collapse all files

327
source/blender/editors/mesh/knifetool.c
View File

@@ -1562,333 +1562,6 @@ cleanup:
BLI_memarena_free(arena);
BLI_smallhash_release(hash);
BMO_pop(bm);
}
/*use edgenet to fill faces. this is a bit annoying and convoluted.*/
void knifenet_fill_faces_old(knifetool_opdata *kcd)
{
BLI_mempool_iter iter;
BMOperator bmop;
BMesh *bm = kcd->em->bm;
BMOIter siter;
BMIter bmiter;
BMFace *f;
BMEdge *e;
KnifeVert *kfv;
KnifeEdge *kfe;
float (*vertcos)[3] = NULL;
void **blocks = NULL;
BLI_array_declare(blocks);
BLI_array_declare(vertcos);
float *w = NULL;
BLI_array_declare(w);
BMO_push(bm, NULL);
BM_ITER(f, &bmiter, bm, BM_FACES_OF_MESH, NULL) {
BMINDEX_SET(f, 0);
}
/*assign a bit flag to each face. adjacent
faces cannot share the same bit flag, nor can
diagonally adjacent faces*/
BM_ITER(f, &bmiter, bm, BM_FACES_OF_MESH, NULL) {
BMIter bmiter2;
BMLoop *l;
int group = 0, ok=0;
while (!ok) {
ok = 1;
BM_ITER(l, &bmiter2, bm, BM_LOOPS_OF_FACE, f) {
BMLoop *l2 = l->radial_next;
while (l2 != l) {
BMLoop *l3;
BMIter bmiter3;
if (l2->f == l->f) {
l2 = l2->radial_next;
continue;
}
if (BMINDEX_GET(l2->f) == (1<<group) && group <= MAXGROUP) {
group++;
ok = 0;
} else if (BMINDEX_GET(l2->f) == (1<<group)) {
printf("yeek! ran out of groups! 1\n");
}
BM_ITER(l3, &bmiter3, bm, BM_LOOPS_OF_FACE, l2->f) {
BMLoop *l4 = l3->radial_next;
do {
if (l4->f == l->f) {
l4 = l4->radial_next;
continue;
}
if (BMINDEX_GET(l4->f) == (1<<group) && group <= MAXGROUP) {
group++;
ok = 0;
} else if (BMINDEX_GET(l4->f) == (1<<group)) {
printf("yeek! ran out of groups! 2`\n");
}
l4 = l4->radial_next;
} while (l4 != l3);
}
l2 = l2->radial_next;
}
}
}
BMINDEX_SET(f, (1<<group));
}
/*turn knife verts into real verts, as necassary*/
BLI_mempool_iternew(kcd->kverts, &iter);
for (kfv=BLI_mempool_iterstep(&iter); kfv; kfv=BLI_mempool_iterstep(&iter)) {
if (!kfv->v) {
kfv->v = BM_Make_Vert(bm, kfv->co, NULL);
kfv->flag = 1;
} else {
kfv->flag = 0;
BMO_SetFlag(bm, kfv->v, VERT_ORIG);
}
BMO_SetFlag(bm, kfv->v, MARK);
}
BMO_InitOpf(bm, &bmop, "edgenet_fill use_restrict=%i", 1);
/*turn knife edges into real edges, and assigns bit masks representing
the faces they are adjacent too*/
BLI_mempool_iternew(kcd->kedges, &iter);
for (kfe=BLI_mempool_iterstep(&iter); kfe; kfe=BLI_mempool_iterstep(&iter)) {
int group = 0;
if (!kfe->v1 || !kfe->v2)
continue;
if (kfe->e) {
BM_ITER(f, &bmiter, bm, BM_FACES_OF_EDGE, kfe->e) {
group |= BMINDEX_GET(f);
if (kfe->v1->v != kfe->e->v1 || kfe->v2->v != kfe->e->v2) {
BMO_SetFlag(bm, f, DEL);
}
}
kfe->oe = kfe->e;
if (kfe->v1->v != kfe->e->v1 || kfe->v2->v != kfe->e->v2) {
BMO_SetFlag(bm, kfe->e, DEL);
BMO_ClearFlag(bm, kfe->e, MARK);
if (kfe->v1->v != kfe->e->v1)
BMO_SetFlag(bm, kfe->v1->v, VERT_ON_EDGE);
if (kfe->v2->v != kfe->e->v2)
BMO_SetFlag(bm, kfe->v2->v, VERT_ON_EDGE);
kfe->e = NULL;
}
}
if (!kfe->e) {
kfe->e = BM_Make_Edge(bm, kfe->v1->v, kfe->v2->v, NULL, 0);
}
BMO_SetFlag(bm, kfe->e, MARK);
if (kfe->basef) {
BMEdge *e;
BM_ITER(e, &bmiter, bm, BM_EDGES_OF_FACE, kfe->basef) {
BMO_SetFlag(bm, e, MARK);
}
BMO_SetFlag(bm, kfe->basef, DEL);
group |= BMINDEX_GET(kfe->basef);
}
if (!group) {
Ref *ref;
for (ref=kfe->faces.first; ref; ref=ref->next) {
kfe->basef = ref->ref;
group |= BMINDEX_GET(ref->ref);
}
}
if (group)
BMO_Insert_MapInt(bm, &bmop, "restrict", kfe->e, group);
else
printf("yeek!\n");
}
/*not sure why this is needed, sanity check to make sure del'd edges are not
marked as well*/
BM_ITER(e, &bmiter, bm, BM_EDGES_OF_MESH, NULL) {
if (BMO_TestFlag(bm, e, DEL))
BMO_ClearFlag(bm, e, MARK);
}
BM_ITER(f, &bmiter, bm, BM_FACES_OF_MESH, NULL) {
BMIter eiter;
if (!BMO_TestFlag(bm, f, DEL))
continue;
BM_ITER(e, &eiter, bm, BM_EDGES_OF_FACE, f) {
BMIter liter;
BMLoop *l;
BMO_SetFlag(bm, e, MARK);
BM_ITER(l, &liter, bm, BM_LOOPS_OF_EDGE, e) {
BMINDEX_SET(e, BMINDEX_GET(e)|BMINDEX_GET(l->f));
}
}
}
BMO_Flag_To_Slot(bm, &bmop, "edges", MARK, BM_EDGE);
BMO_Flag_To_Slot(bm, &bmop, "excludefaces", DEL, BM_FACE);
/*execute the edgenet fill operator. it will restrict filled faces to edges
belonging to the same group (note edges can belong to multiple groups, using
bitmasks)*/
BMO_Exec_Op(bm, &bmop);
BMO_Flag_Buffer(bm, &bmop, "faceout", MARK, BM_FACE);
BM_Compute_Normals(bm);
//void interp_weights_poly_v3(float *w,float v[][3], int n, float *co)
/* interpolate customdata */
/*first deal with interpolating vertices that lie on original edges*/
BLI_mempool_iternew(kcd->kedges, &iter);
for (kfe=BLI_mempool_iterstep(&iter); kfe; kfe=BLI_mempool_iterstep(&iter)) {
BMLoop *l1, *l2;
float fac, w[2];
void *blocks[2];
if (!kfe->oe)
continue;
BM_ITER(l1, &bmiter, bm, BM_LOOPS_OF_EDGE, kfe->oe) {
BMLoop *l2 = NULL;
BMIter liter;
int i, j;
BM_ITER(l2, &liter, bm, BM_LOOPS_OF_EDGE, kfe->e) {
if (!BM_Vert_In_Edge(kfe->e, l2->next->v)) {
l2 = l2->prev;
}
if (!BMO_InMap(bm, &bmop, "faceout_groupmap", l2->f))
continue;
if (BMINDEX_GET(l1->f) == BMO_Get_MapInt(bm, &bmop, "faceout_groupmap", l2->f))
break;
}
if (!l2)
continue;
if (dot_v3v3(l1->f->no, l2->f->no) < 0.0f) {
BMO_SetFlag(bm, l2->f, FACE_FLIP);
}
for (i=0; i<2; i++) {
if (i)
l2 = l2->next;
fac = len_v3v3(kfe->oe->v1->co, l2->v->co) / (len_v3v3(kfe->oe->v1->co, kfe->oe->v2->co)+FLT_EPSILON);
if (kfe->oe->v1 == l1->v) {
w[0] = 1.0-fac;
w[1] = fac;
} else {
w[0] = fac;
w[1] = 1.0-fac;
}
if (l1->e == kfe->oe) {
blocks[0] = l1->head.data;
blocks[1] = l1->next->head.data;
} else {
blocks[0] = l1->prev->head.data;
blocks[1] = l1->head.data;
}
BM_Copy_Attributes(bm, bm, l1->f, l2->f);
CustomData_bmesh_interp(&bm->ldata, blocks, w, NULL, 2, l2->head.data);
}
}
}
/*ensure normals are correct*/
BM_ITER(f, &bmiter, bm, BM_FACES_OF_MESH, NULL) {
if (BMO_TestFlag(bm, f, FACE_FLIP)) {
BM_flip_normal(bm, f);
}
}
/*now deal with interior vertex interpolation
still kindof buggy*/
BMO_ITER(f, &siter, bm, &bmop, "faceout_groupmap", BM_FACE) {
BMLoop *l1, *l2;
BMFace *f2;
BMIter liter1, liter2;
int group = *(int*)BMO_IterMapVal(&siter);
BM_ITER(l1, &liter1, bm, BM_LOOPS_OF_FACE, f) {
float co[3], hit[3];
float dir[3];
int i;
if (BMO_TestFlag(bm, l1->v, VERT_ORIG) || BMO_TestFlag(bm, l1->v, VERT_ON_EDGE))
continue;
copy_v3_v3(co, l1->v->co);
copy_v3_v3(dir, l1->v->no);
mul_v3_fl(dir, 0.001f);
add_v3_v3(co, dir);
copy_v3_v3(dir, l1->v->no);
mul_v3_fl(dir, -1.0);
f2 = BMBVH_RayCast(kcd->bmbvh, co, dir, hit);
if (!f2) {
printf("eek!!\n");
continue;
}
BLI_array_empty(vertcos);
BLI_array_empty(blocks);
BLI_array_empty(w);
BM_ITER(l2, &liter2, bm, BM_LOOPS_OF_FACE, f2) {
BLI_array_growone(vertcos);
BLI_array_append(blocks, l2->head.data);
copy_v3_v3(vertcos[BLI_array_count(vertcos)-1], l2->v->co);
BLI_array_append(w, 0.0f);
}
BM_Copy_Attributes(bm, bm, f2, f);
interp_weights_poly_v3(w, vertcos, f2->len, l1->v->co);
CustomData_bmesh_interp(&bm->ldata, blocks, w, NULL, BLI_array_count(blocks), l1->head.data);
}
}
BMO_Finish_Op(bm, &bmop);
/*delete left over faces*/
BMO_CallOpf(bm, "del geom=%ff context=%i", DEL, DEL_ONLYFACES);
BMO_CallOpf(bm, "del geom=%fe context=%i", DEL, DEL_EDGES);
BMO_pop(bm);
BMO_ClearStack(bm); /*remerge_faces sometimes raises errors, so make sure to clear them*/
}