forked from bartvdbraak/blender
Code Cleanup:
* made bmesh_structure.h function names more consistant. * remove unused code in bmesh_structure.c * removed 'Edge Flip' operator (missing from bmesh but looked into trunk feature and dont think its worth keeping). * tagged some BMESH_TODO's
This commit is contained in:
parent
08b35cda7f
commit
e17bf02c2d
@ -333,7 +333,7 @@ kmi = km.keymap_items.new('mesh.fill', 'F', 'PRESS', alt=True)
|
||||
kmi = km.keymap_items.new('mesh.beautify_fill', 'F', 'PRESS', shift=True, alt=True)
|
||||
kmi = km.keymap_items.new('mesh.quads_convert_to_tris', 'T', 'PRESS', ctrl=True)
|
||||
kmi = km.keymap_items.new('mesh.tris_convert_to_quads', 'J', 'PRESS', alt=True)
|
||||
kmi = km.keymap_items.new('mesh.edge_flip', 'F', 'PRESS', shift=True, ctrl=True)
|
||||
# kmi = km.keymap_items.new('mesh.edge_flip', 'F', 'PRESS', shift=True, ctrl=True) # removed since bmesh, can be made into something else?
|
||||
kmi = km.keymap_items.new('mesh.rip_move', 'V', 'PRESS')
|
||||
kmi = km.keymap_items.new('mesh.merge', 'M', 'PRESS', alt=True)
|
||||
kmi = km.keymap_items.new('transform.shrink_fatten', 'S', 'PRESS', ctrl=True, alt=True)
|
||||
|
@ -1720,7 +1720,6 @@ class VIEW3D_MT_edit_mesh_faces(Menu):
|
||||
|
||||
layout.operator("mesh.quads_convert_to_tris")
|
||||
layout.operator("mesh.tris_convert_to_quads")
|
||||
layout.operator("mesh.edge_flip")
|
||||
|
||||
layout.separator()
|
||||
|
||||
|
@ -62,14 +62,7 @@ extern "C" {
|
||||
*/
|
||||
|
||||
/*forward declarations*/
|
||||
struct BMesh;
|
||||
struct BMVert;
|
||||
struct BMEdge;
|
||||
struct BMFace;
|
||||
struct BMLoop;
|
||||
struct BMOperator;
|
||||
struct Mesh;
|
||||
struct EditMesh;
|
||||
|
||||
/*
|
||||
* BMHeader
|
||||
@ -216,7 +209,7 @@ BMFace *BM_faces_join(BMesh *bm, BMFace **faces, int totface);
|
||||
* the nl member to a loop in the newly created edge.*/
|
||||
BMFace *BM_face_split(BMesh *bm, BMFace *f,
|
||||
BMVert *v1, BMVert *v2,
|
||||
struct BMLoop **nl, BMEdge *example);
|
||||
BMLoop **nl, BMEdge *example);
|
||||
|
||||
/* these 2 functions are very similar */
|
||||
BMEdge* BM_vert_collapse_faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac,
|
||||
@ -287,13 +280,13 @@ void BM_loop_interp_multires(BMesh *bm, BMLoop *target, BMFace *source);
|
||||
void BM_vert_interp_from_face(BMesh *bm, BMVert *v, BMFace *source);
|
||||
|
||||
void BM_data_interp_from_verts(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v, const float fac);
|
||||
void BM_data_interp_face_vert_edge(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v, struct BMEdge *e1, const float fac);
|
||||
void BM_data_interp_face_vert_edge(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v, BMEdge *e1, const float fac);
|
||||
void BM_data_layer_add(BMesh *em, CustomData *data, int type);
|
||||
void BM_data_layer_add_named(BMesh *bm, CustomData *data, int type, const char *name);
|
||||
void BM_data_layer_free(BMesh *em, CustomData *data, int type);
|
||||
void BM_data_layer_free_n(BMesh *bm, CustomData *data, int type, int n);
|
||||
float BM_elem_float_data_get(struct CustomData *cd, void *element, int type);
|
||||
void BM_elem_float_data_set(struct CustomData *cd, void *element, int type, const float val);
|
||||
float BM_elem_float_data_get(CustomData *cd, void *element, int type);
|
||||
void BM_elem_float_data_set(CustomData *cd, void *element, int type, const float val);
|
||||
|
||||
/* get the area of the face */
|
||||
float BM_face_area_calc(BMesh *bm, BMFace *f);
|
||||
|
@ -30,24 +30,23 @@
|
||||
/* bmesh data structures */
|
||||
|
||||
/* dissable holes for now, these are ifdef'd because they use more memory and cant be saved in DNA currently */
|
||||
#define USE_BMESH_HOLES
|
||||
// #define USE_BMESH_HOLES
|
||||
|
||||
struct BMesh;
|
||||
struct BMVert;
|
||||
struct BMEdge;
|
||||
struct BMLoop;
|
||||
struct BMFace;
|
||||
struct BMFlagLayer;
|
||||
struct BMLayerType;
|
||||
struct BMSubClassLayer;
|
||||
|
||||
struct BLI_mempool;
|
||||
struct Object;
|
||||
|
||||
/*note: it is very important for BMHeader to start with two
|
||||
pointers. this is a requirement of mempool's method of
|
||||
iteration.
|
||||
*/
|
||||
/* note: it is very important for BMHeader to start with two
|
||||
* pointers. this is a requirement of mempool's method of
|
||||
* iteration.
|
||||
*
|
||||
* hrm. it doesnt but stull works ok, remove the comment above? - campbell.
|
||||
*/
|
||||
typedef struct BMHeader {
|
||||
void *data; /* customdata layers */
|
||||
int index; /* notes:
|
||||
@ -102,7 +101,7 @@ typedef struct BMLoop {
|
||||
|
||||
/* these were originally commented as private but are used all over the code */
|
||||
/* can't use ListBase API, due to head */
|
||||
struct BMLoop *next, *prev;
|
||||
struct BMLoop *next, *prev; /* next/prev verts around the face */
|
||||
} BMLoop;
|
||||
|
||||
/* can cast BMFace/BMEdge/BMVert, but NOT BMLoop, since these dont have a flag layer */
|
||||
|
@ -94,11 +94,11 @@ extern const char bm_iter_itype_htype_map[BM_ITYPE_MAX];
|
||||
typedef struct BMIter {
|
||||
BLI_mempool_iter pooliter;
|
||||
|
||||
struct BMVert *firstvert, *nextvert, *vdata;
|
||||
struct BMEdge *firstedge, *nextedge, *edata;
|
||||
struct BMLoop *firstloop, *nextloop, *ldata, *l;
|
||||
struct BMFace *firstpoly, *nextpoly, *pdata;
|
||||
struct BMesh *bm;
|
||||
BMVert *firstvert, *nextvert, *vdata;
|
||||
BMEdge *firstedge, *nextedge, *edata;
|
||||
BMLoop *firstloop, *nextloop, *ldata, *l;
|
||||
BMFace *firstpoly, *nextpoly, *pdata;
|
||||
BMesh *bm;
|
||||
void (*begin)(struct BMIter *iter);
|
||||
void *(*step)(struct BMIter *iter);
|
||||
union {
|
||||
@ -111,8 +111,8 @@ typedef struct BMIter {
|
||||
char itype;
|
||||
} BMIter;
|
||||
|
||||
void *BM_iter_at_index(struct BMesh *bm, const char itype, void *data, int index);
|
||||
int BM_iter_as_array(struct BMesh *bm, const char itype, void *data, void **array, const int len);
|
||||
void *BM_iter_at_index(BMesh *bm, const char itype, void *data, int index);
|
||||
int BM_iter_as_array(BMesh *bm, const char itype, void *data, void **array, const int len);
|
||||
|
||||
/* private for bmesh_iterators_inline.c */
|
||||
void bmiter__vert_of_mesh_begin(struct BMIter *iter);
|
||||
|
@ -41,7 +41,7 @@ void BM_edge_hide_set(BMesh *bm, BMEdge *e, int hide);
|
||||
void BM_face_hide_set(BMesh *bm, BMFace *f, int hide);
|
||||
|
||||
/* Selection code */
|
||||
void BM_elem_select_set(struct BMesh *bm, void *element, int select);
|
||||
void BM_elem_select_set(BMesh *bm, void *element, int select);
|
||||
|
||||
/* use BM_elem_flag_test(ele, BM_ELEM_SELECT) to test selection */
|
||||
|
||||
@ -50,14 +50,14 @@ void BM_mesh_elem_flag_disable_all(BMesh *bm, const char htype, const char hflag
|
||||
|
||||
/* individual element select functions, BM_elem_select_set is a shortcut for these
|
||||
* that automatically detects which one to use*/
|
||||
void BM_vert_select_set(struct BMesh *bm, struct BMVert *v, int select);
|
||||
void BM_edge_select_set(struct BMesh *bm, struct BMEdge *e, int select);
|
||||
void BM_face_select_set(struct BMesh *bm, struct BMFace *f, int select);
|
||||
void BM_vert_select_set(BMesh *bm, BMVert *v, int select);
|
||||
void BM_edge_select_set(BMesh *bm, BMEdge *e, int select);
|
||||
void BM_face_select_set(BMesh *bm, BMFace *f, int select);
|
||||
|
||||
void BM_select_mode_set(struct BMesh *bm, int selectmode);
|
||||
void BM_select_mode_set(BMesh *bm, int selectmode);
|
||||
|
||||
/* counts number of elements with flag set */
|
||||
int BM_mesh_count_flag(struct BMesh *bm, const char htype, const char hflag, int respecthide);
|
||||
int BM_mesh_count_flag(BMesh *bm, const char htype, const char hflag, int respecthide);
|
||||
|
||||
/* edit selection stuff */
|
||||
void BM_active_face_set(BMesh *em, BMFace *f);
|
||||
|
@ -140,8 +140,7 @@ typedef struct BMOperator {
|
||||
int slottype;
|
||||
int needflag;
|
||||
int flag;
|
||||
struct BMOpSlot slots[BMO_OP_MAX_SLOTS];
|
||||
void (*exec)(struct BMesh *bm, struct BMOperator *op);
|
||||
struct BMOpSlot slots[BMO_OP_MAX_SLOTS]; void (*exec)(BMesh *bm, struct BMOperator *op);
|
||||
MemArena *arena;
|
||||
} BMOperator;
|
||||
|
||||
|
@ -93,10 +93,9 @@ extern int bmesh_total_ops;
|
||||
* to get more useful information (such as the mapping from
|
||||
* original to new elements) you should run the dupe op manually.*/
|
||||
struct Object;
|
||||
struct EditMesh;
|
||||
|
||||
#if 0
|
||||
void BMO_dupe_from_flag(struct BMesh *bm, int etypeflag, const char hflag);
|
||||
void BMO_dupe_from_flag(BMesh *bm, int etypeflag, const char hflag);
|
||||
#endif
|
||||
void BM_mesh_esubdivideflag(struct Object *obedit, BMesh *bm, int flag, float smooth,
|
||||
float fractal, int beauty, int numcuts, int seltype,
|
||||
|
@ -205,7 +205,7 @@ BMFace *BM_face_create_ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, i
|
||||
BLI_array_append(edges2, e);
|
||||
|
||||
do {
|
||||
e2 = bmesh_disk_nextedge(e2, v);
|
||||
e2 = bmesh_disk_edge_next(e2, v);
|
||||
if (e2 != e && BM_ELEM_API_FLAG_TEST(e2, _FLAG_MF)) {
|
||||
v = BM_edge_other_vert(e2, v);
|
||||
break;
|
||||
|
@ -197,7 +197,7 @@ void *bmiter__edge_of_vert_step(BMIter *iter)
|
||||
BMEdge *current = iter->nextedge;
|
||||
|
||||
if (iter->nextedge)
|
||||
iter->nextedge = bmesh_disk_nextedge(iter->nextedge, iter->vdata);
|
||||
iter->nextedge = bmesh_disk_edge_next(iter->nextedge, iter->vdata);
|
||||
|
||||
if (iter->nextedge == iter->firstedge) iter->nextedge = NULL;
|
||||
|
||||
@ -214,11 +214,11 @@ void bmiter__face_of_vert_begin(BMIter *iter)
|
||||
init_iterator(iter);
|
||||
iter->count = 0;
|
||||
if (iter->vdata->e)
|
||||
iter->count = bmesh_disk_count_facevert(iter->vdata);
|
||||
iter->count = bmesh_disk_facevert_count(iter->vdata);
|
||||
if (iter->count) {
|
||||
iter->firstedge = bmesh_disk_find_first_faceedge(iter->vdata->e, iter->vdata);
|
||||
iter->firstedge = bmesh_disk_faceedge_find_first(iter->vdata->e, iter->vdata);
|
||||
iter->nextedge = iter->firstedge;
|
||||
iter->firstloop = bmesh_radial_find_first_faceloop(iter->firstedge->l, iter->vdata);
|
||||
iter->firstloop = bmesh_radial_faceloop_find_first(iter->firstedge->l, iter->vdata);
|
||||
iter->nextloop = iter->firstloop;
|
||||
}
|
||||
}
|
||||
@ -228,10 +228,10 @@ void *bmiter__face_of_vert_step(BMIter *iter)
|
||||
|
||||
if (iter->count && iter->nextloop) {
|
||||
iter->count--;
|
||||
iter->nextloop = bmesh_radial_find_next_faceloop(iter->nextloop, iter->vdata);
|
||||
iter->nextloop = bmesh_radial_faceloop_find_next(iter->nextloop, iter->vdata);
|
||||
if (iter->nextloop == iter->firstloop) {
|
||||
iter->nextedge = bmesh_disk_find_next_faceedge(iter->nextedge, iter->vdata);
|
||||
iter->firstloop = bmesh_radial_find_first_faceloop(iter->nextedge->l, iter->vdata);
|
||||
iter->nextedge = bmesh_disk_faceedge_find_next(iter->nextedge, iter->vdata);
|
||||
iter->firstloop = bmesh_radial_faceloop_find_first(iter->nextedge->l, iter->vdata);
|
||||
iter->nextloop = iter->firstloop;
|
||||
}
|
||||
}
|
||||
@ -252,11 +252,11 @@ void bmiter__loop_of_vert_begin(BMIter *iter)
|
||||
init_iterator(iter);
|
||||
iter->count = 0;
|
||||
if (iter->vdata->e)
|
||||
iter->count = bmesh_disk_count_facevert(iter->vdata);
|
||||
iter->count = bmesh_disk_facevert_count(iter->vdata);
|
||||
if (iter->count) {
|
||||
iter->firstedge = bmesh_disk_find_first_faceedge(iter->vdata->e, iter->vdata);
|
||||
iter->firstedge = bmesh_disk_faceedge_find_first(iter->vdata->e, iter->vdata);
|
||||
iter->nextedge = iter->firstedge;
|
||||
iter->firstloop = bmesh_radial_find_first_faceloop(iter->firstedge->l, iter->vdata);
|
||||
iter->firstloop = bmesh_radial_faceloop_find_first(iter->firstedge->l, iter->vdata);
|
||||
iter->nextloop = iter->firstloop;
|
||||
}
|
||||
}
|
||||
@ -266,10 +266,10 @@ void *bmiter__loop_of_vert_step(BMIter *iter)
|
||||
|
||||
if (iter->count) {
|
||||
iter->count--;
|
||||
iter->nextloop = bmesh_radial_find_next_faceloop(iter->nextloop, iter->vdata);
|
||||
iter->nextloop = bmesh_radial_faceloop_find_next(iter->nextloop, iter->vdata);
|
||||
if (iter->nextloop == iter->firstloop) {
|
||||
iter->nextedge = bmesh_disk_find_next_faceedge(iter->nextedge, iter->vdata);
|
||||
iter->firstloop = bmesh_radial_find_first_faceloop(iter->nextedge->l, iter->vdata);
|
||||
iter->nextedge = bmesh_disk_faceedge_find_next(iter->nextedge, iter->vdata);
|
||||
iter->firstloop = bmesh_radial_faceloop_find_first(iter->nextedge->l, iter->vdata);
|
||||
iter->nextloop = iter->firstloop;
|
||||
}
|
||||
}
|
||||
@ -302,7 +302,7 @@ void *bmiter__loops_of_edge_step(BMIter *iter)
|
||||
BMLoop *current = iter->nextloop;
|
||||
|
||||
if (iter->nextloop)
|
||||
iter->nextloop = bmesh_radial_nextloop(iter->nextloop);
|
||||
iter->nextloop = bmesh_radial_loop_next(iter->nextloop);
|
||||
|
||||
if (iter->nextloop == iter->firstloop)
|
||||
iter->nextloop = NULL;
|
||||
@ -324,7 +324,7 @@ void bmiter__loops_of_loop_begin(BMIter *iter)
|
||||
init_iterator(iter);
|
||||
|
||||
iter->firstloop = l;
|
||||
iter->nextloop = bmesh_radial_nextloop(iter->firstloop);
|
||||
iter->nextloop = bmesh_radial_loop_next(iter->firstloop);
|
||||
|
||||
if (iter->nextloop == iter->firstloop)
|
||||
iter->nextloop = NULL;
|
||||
@ -334,7 +334,7 @@ void *bmiter__loops_of_loop_step(BMIter *iter)
|
||||
{
|
||||
BMLoop *current = iter->nextloop;
|
||||
|
||||
if (iter->nextloop) iter->nextloop = bmesh_radial_nextloop(iter->nextloop);
|
||||
if (iter->nextloop) iter->nextloop = bmesh_radial_loop_next(iter->nextloop);
|
||||
|
||||
if (iter->nextloop == iter->firstloop) iter->nextloop = NULL;
|
||||
|
||||
@ -364,7 +364,7 @@ void *bmiter__face_of_edge_step(BMIter *iter)
|
||||
{
|
||||
BMLoop *current = iter->nextloop;
|
||||
|
||||
if (iter->nextloop) iter->nextloop = bmesh_radial_nextloop(iter->nextloop);
|
||||
if (iter->nextloop) iter->nextloop = bmesh_radial_loop_next(iter->nextloop);
|
||||
|
||||
if (iter->nextloop == iter->firstloop) iter->nextloop = NULL;
|
||||
|
||||
|
@ -56,7 +56,6 @@
|
||||
*
|
||||
*
|
||||
*/
|
||||
#if 1
|
||||
int BM_vert_dissolve(BMesh *bm, BMVert *v)
|
||||
{
|
||||
const int len = BM_vert_edge_count(v);
|
||||
@ -107,7 +106,7 @@ int BM_disk_dissolve(BMesh *bm, BMVert *v)
|
||||
/* v->e we keep, what else */
|
||||
e = v->e;
|
||||
do {
|
||||
e = bmesh_disk_nextedge(e, v);
|
||||
e = bmesh_disk_edge_next(e, v);
|
||||
if (!(BM_edge_share_face_count(e, v->e))) {
|
||||
keepedge = e;
|
||||
baseedge = v->e;
|
||||
@ -174,7 +173,7 @@ int BM_disk_dissolve(BMesh *bm, BMVert *v)
|
||||
done = 0;
|
||||
break;
|
||||
}
|
||||
e = bmesh_disk_nextedge(e, v);
|
||||
e = bmesh_disk_edge_next(e, v);
|
||||
} while (e != v->e);
|
||||
}
|
||||
|
||||
@ -199,37 +198,6 @@ int BM_disk_dissolve(BMesh *bm, BMVert *v)
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
#else
|
||||
void BM_disk_dissolve(BMesh *bm, BMVert *v)
|
||||
{
|
||||
BMFace *f;
|
||||
BMEdge *e;
|
||||
BMIter iter;
|
||||
int done, len;
|
||||
|
||||
if (v->e) {
|
||||
done = 0;
|
||||
while (!done) {
|
||||
done = 1;
|
||||
|
||||
/* loop the edges looking for an edge to dissolv */
|
||||
for (e = BM_iter_new(&iter, bm, BM_EDGES_OF_VERT, v); e;
|
||||
e = BM_iter_step(&iter)) {
|
||||
f = NULL;
|
||||
len = bmesh_cycle_length(&(e->l->radial));
|
||||
if (len == 2) {
|
||||
f = BM_faces_join_pair(bm, e->l->f, ((BMLoop *)(e->l->radial_next))->f, e);
|
||||
}
|
||||
if (f) {
|
||||
done = 0;
|
||||
break;
|
||||
}
|
||||
};
|
||||
}
|
||||
BM_vert_collapse_faces(bm, v->e, v, 1.0, TRUE);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* BM_faces_join_pair
|
||||
@ -414,7 +382,7 @@ BMEdge *BM_vert_collapse_faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac,
|
||||
const short join_faces, const short kill_degenerate_faces)
|
||||
{
|
||||
BMEdge *ne = NULL;
|
||||
BMVert *tv = bmesh_edge_getothervert(ke, kv);
|
||||
BMVert *tv = bmesh_edge_other_vert_get(ke, kv);
|
||||
|
||||
BMEdge *e2;
|
||||
BMVert *tv2;
|
||||
@ -450,7 +418,7 @@ BMEdge *BM_vert_collapse_faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac,
|
||||
/* now interpolate the vertex data */
|
||||
BM_data_interp_from_verts(bm, kv, tv, kv, fac);
|
||||
|
||||
e2 = bmesh_disk_nextedge(ke, kv);
|
||||
e2 = bmesh_disk_edge_next(ke, kv);
|
||||
tv2 = BM_edge_other_vert(e2, kv);
|
||||
|
||||
if (join_faces) {
|
||||
@ -520,9 +488,9 @@ BMEdge *BM_vert_collapse_edge(BMesh *bm, BMEdge *ke, BMVert *kv,
|
||||
|
||||
/* in this case we want to keep all faces and not join them,
|
||||
* rather just get rid of the veretex - see bug [#28645] */
|
||||
BMVert *tv = bmesh_edge_getothervert(ke, kv);
|
||||
BMVert *tv = bmesh_edge_other_vert_get(ke, kv);
|
||||
if (tv) {
|
||||
BMEdge *e2 = bmesh_disk_nextedge(ke, kv);
|
||||
BMEdge *e2 = bmesh_disk_edge_next(ke, kv);
|
||||
if (e2) {
|
||||
BMVert *tv2 = BM_edge_other_vert(e2, kv);
|
||||
if (tv2) {
|
||||
@ -587,7 +555,7 @@ BMVert *BM_edge_split(BMesh *bm, BMEdge *e, BMVert *v, BMEdge **ne, float percen
|
||||
}
|
||||
}
|
||||
|
||||
v2 = bmesh_edge_getothervert(e, v);
|
||||
v2 = bmesh_edge_other_vert_get(e, v);
|
||||
nv = bmesh_semv(bm, v, e, ne);
|
||||
if (nv == NULL) {
|
||||
return NULL;
|
||||
|
@ -142,8 +142,8 @@ BMEdge *BM_edge_create(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *example,
|
||||
|
||||
CustomData_bmesh_set_default(&bm->edata, &e->head.data);
|
||||
|
||||
bmesh_disk_append_edge(e, e->v1);
|
||||
bmesh_disk_append_edge(e, e->v2);
|
||||
bmesh_disk_edge_append(e, e->v1);
|
||||
bmesh_disk_edge_append(e, e->v2);
|
||||
|
||||
if (example)
|
||||
BM_elem_attrs_copy(bm, bm, example, e);
|
||||
@ -577,7 +577,7 @@ void BM_face_kill(BMesh *bm, BMFace *f)
|
||||
do {
|
||||
l_next = l_iter->next;
|
||||
|
||||
bmesh_radial_remove_loop(l_iter, l_iter->e);
|
||||
bmesh_radial_loop_remove(l_iter, l_iter->e);
|
||||
bmesh_kill_only_loop(bm, l_iter);
|
||||
|
||||
} while ((l_iter = l_next) != l_first);
|
||||
@ -593,8 +593,8 @@ void BM_face_kill(BMesh *bm, BMFace *f)
|
||||
void BM_edge_kill(BMesh *bm, BMEdge *e)
|
||||
{
|
||||
|
||||
bmesh_disk_remove_edge(e, e->v1);
|
||||
bmesh_disk_remove_edge(e, e->v2);
|
||||
bmesh_disk_edge_remove(e, e->v1);
|
||||
bmesh_disk_edge_remove(e, e->v2);
|
||||
|
||||
if (e->l) {
|
||||
BMLoop *l = e->l, *lnext, *startl = e->l;
|
||||
@ -624,7 +624,7 @@ void BM_vert_kill(BMesh *bm, BMVert *v)
|
||||
|
||||
e = v->e;
|
||||
while (v->e) {
|
||||
nexte = bmesh_disk_nextedge(e, v);
|
||||
nexte = bmesh_disk_edge_next(e, v);
|
||||
BM_edge_kill(bm, e);
|
||||
e = nexte;
|
||||
}
|
||||
@ -685,7 +685,7 @@ static int bmesh_loop_reverse_loop(BMesh *bm, BMFace *f
|
||||
|
||||
for (i = 0, l_iter = l_first; i < len; i++, l_iter = l_iter->next) {
|
||||
BMEdge *curedge = l_iter->e;
|
||||
bmesh_radial_remove_loop(l_iter, curedge);
|
||||
bmesh_radial_loop_remove(l_iter, curedge);
|
||||
BLI_array_append(edar, curedge);
|
||||
}
|
||||
|
||||
@ -795,7 +795,7 @@ static int count_flagged_radial(BMesh *bm, BMLoop *l, int flag)
|
||||
}
|
||||
|
||||
i += BM_ELEM_API_FLAG_TEST(l2->f, flag) ? 1 : 0;
|
||||
l2 = bmesh_radial_nextloop(l2);
|
||||
l2 = bmesh_radial_loop_next(l2);
|
||||
if (UNLIKELY(c >= BM_LOOP_RADIAL_MAX)) {
|
||||
BMESH_ASSERT(0);
|
||||
goto error;
|
||||
@ -820,7 +820,7 @@ static int UNUSED_FUNCTION(count_flagged_disk)(BMVert *v, int flag)
|
||||
|
||||
do {
|
||||
i += BM_ELEM_API_FLAG_TEST(e, flag) ? 1 : 0;
|
||||
e = bmesh_disk_nextedge(e, v);
|
||||
e = bmesh_disk_edge_next(e, v);
|
||||
} while (e != v->e);
|
||||
|
||||
return i;
|
||||
@ -850,7 +850,7 @@ static int disk_is_flagged(BMVert *v, int flag)
|
||||
l = l->radial_next;
|
||||
} while (l != e->l);
|
||||
|
||||
e = bmesh_disk_nextedge(e, v);
|
||||
e = bmesh_disk_edge_next(e, v);
|
||||
} while (e != v->e);
|
||||
|
||||
return TRUE;
|
||||
@ -1255,7 +1255,7 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
|
||||
if (bmesh_vert_in_edge(e, tv) == 0) {
|
||||
return NULL;
|
||||
}
|
||||
ov = bmesh_edge_getothervert(e, tv);
|
||||
ov = bmesh_edge_other_vert_get(e, tv);
|
||||
|
||||
/* count valence of v1 */
|
||||
valence1 = bmesh_disk_count(ov);
|
||||
@ -1266,23 +1266,23 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
|
||||
nv = BM_vert_create(bm, tv->co, tv);
|
||||
ne = BM_edge_create(bm, nv, tv, e, FALSE);
|
||||
|
||||
bmesh_disk_remove_edge(ne, tv);
|
||||
bmesh_disk_remove_edge(ne, nv);
|
||||
bmesh_disk_edge_remove(ne, tv);
|
||||
bmesh_disk_edge_remove(ne, nv);
|
||||
|
||||
/* remove e from v2's disk cycle */
|
||||
bmesh_disk_remove_edge(e, tv);
|
||||
bmesh_disk_edge_remove(e, tv);
|
||||
|
||||
/* swap out tv for nv in e */
|
||||
bmesh_edge_swapverts(e, tv, nv);
|
||||
|
||||
/* add e to nv's disk cycl */
|
||||
bmesh_disk_append_edge(e, nv);
|
||||
bmesh_disk_edge_append(e, nv);
|
||||
|
||||
/* add ne to nv's disk cycl */
|
||||
bmesh_disk_append_edge(ne, nv);
|
||||
bmesh_disk_edge_append(ne, nv);
|
||||
|
||||
/* add ne to tv's disk cycl */
|
||||
bmesh_disk_append_edge(ne, tv);
|
||||
bmesh_disk_edge_append(ne, tv);
|
||||
|
||||
/* verify disk cycle */
|
||||
edok = bmesh_disk_validate(valence1, ov->e, ov);
|
||||
@ -1305,7 +1305,7 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
|
||||
l = nextl;
|
||||
l->f->len++;
|
||||
nextl = nextl != nextl->radial_next ? nextl->radial_next : NULL;
|
||||
bmesh_radial_remove_loop(l, NULL);
|
||||
bmesh_radial_loop_remove(l, NULL);
|
||||
|
||||
nl = bmesh_create_loop(bm, NULL, NULL, l->f, l);
|
||||
nl->prev = l;
|
||||
@ -1449,9 +1449,9 @@ struct BMEdge *bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv, const short check_e
|
||||
len = bmesh_disk_count(kv);
|
||||
|
||||
if (len == 2) {
|
||||
oe = bmesh_disk_nextedge(ke, kv);
|
||||
tv = bmesh_edge_getothervert(ke, kv);
|
||||
ov = bmesh_edge_getothervert(oe, kv);
|
||||
oe = bmesh_disk_edge_next(ke, kv);
|
||||
tv = bmesh_edge_other_vert_get(ke, kv);
|
||||
ov = bmesh_edge_other_vert_get(oe, kv);
|
||||
halt = bmesh_verts_in_edge(kv, tv, oe); /* check for double edge */
|
||||
|
||||
if (halt) {
|
||||
@ -1469,19 +1469,19 @@ struct BMEdge *bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv, const short check_e
|
||||
}
|
||||
|
||||
/* remove oe from kv's disk cycl */
|
||||
bmesh_disk_remove_edge(oe, kv);
|
||||
bmesh_disk_edge_remove(oe, kv);
|
||||
/* relink oe->kv to be oe->t */
|
||||
bmesh_edge_swapverts(oe, kv, tv);
|
||||
/* append oe to tv's disk cycl */
|
||||
bmesh_disk_append_edge(oe, tv);
|
||||
bmesh_disk_edge_append(oe, tv);
|
||||
/* remove ke from tv's disk cycl */
|
||||
bmesh_disk_remove_edge(ke, tv);
|
||||
bmesh_disk_edge_remove(ke, tv);
|
||||
|
||||
/* deal with radial cycle of k */
|
||||
radlen = bmesh_radial_length(ke->l);
|
||||
if (ke->l) {
|
||||
/* first step, fix the neighboring loops of all loops in ke's radial cycl */
|
||||
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_loop_next(killoop)) {
|
||||
/* relink loops and fix vertex pointer */
|
||||
if (killoop->next->v == kv) {
|
||||
killoop->next->v = tv;
|
||||
@ -1510,7 +1510,7 @@ struct BMEdge *bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv, const short check_e
|
||||
/* this should be wrapped into a bme_free_radial function to be used by bmesh_KF as well.. */
|
||||
for (i = 0; i < radlen; i++) {
|
||||
loops[i] = killoop;
|
||||
killoop = bmesh_radial_nextloop(killoop);
|
||||
killoop = bmesh_radial_loop_next(killoop);
|
||||
}
|
||||
for (i = 0; i < radlen; i++) {
|
||||
bm->totloop--;
|
||||
@ -1537,7 +1537,7 @@ struct BMEdge *bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv, const short check_e
|
||||
BMESH_ASSERT(edok != FALSE);
|
||||
|
||||
/* Validate loop cycle of all faces attached to o */
|
||||
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_loop_next(l)) {
|
||||
BMESH_ASSERT(l->e == oe);
|
||||
edok = bmesh_verts_in_edge(l->v, l->next->v, oe);
|
||||
BMESH_ASSERT(edok != FALSE);
|
||||
@ -1641,10 +1641,10 @@ BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e)
|
||||
|
||||
/* validate that for each face, each vertex has another edge in its disk cycle that is
|
||||
* not e, and not shared. */
|
||||
if ( bmesh_radial_find_face(f1loop->next->e, f2) ||
|
||||
bmesh_radial_find_face(f1loop->prev->e, f2) ||
|
||||
bmesh_radial_find_face(f2loop->next->e, f1) ||
|
||||
bmesh_radial_find_face(f2loop->prev->e, f1) )
|
||||
if ( bmesh_radial_face_find(f1loop->next->e, f2) ||
|
||||
bmesh_radial_face_find(f1loop->prev->e, f2) ||
|
||||
bmesh_radial_face_find(f2loop->next->e, f1) ||
|
||||
bmesh_radial_face_find(f2loop->prev->e, f1) )
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
@ -1697,8 +1697,8 @@ BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e)
|
||||
l_iter->f = f1;
|
||||
|
||||
/* remove edge from the disk cycle of its two vertices */
|
||||
bmesh_disk_remove_edge(f1loop->e, f1loop->e->v1);
|
||||
bmesh_disk_remove_edge(f1loop->e, f1loop->e->v2);
|
||||
bmesh_disk_edge_remove(f1loop->e, f1loop->e->v1);
|
||||
bmesh_disk_edge_remove(f1loop->e, f1loop->e->v2);
|
||||
|
||||
/* deallocate edge and its two loops as well as f2 */
|
||||
BLI_mempool_free(bm->toolflagpool, f1loop->e->oflags);
|
||||
@ -1747,9 +1747,9 @@ static int bmesh_vert_splice(BMesh *bm, BMVert *v, BMVert *vtarget)
|
||||
/* move all the edges from v's disk to vtarget's disk */
|
||||
e = v->e;
|
||||
while (e != NULL) {
|
||||
bmesh_disk_remove_edge(e, v);
|
||||
bmesh_disk_edge_remove(e, v);
|
||||
bmesh_edge_swapverts(e, v, vtarget);
|
||||
bmesh_disk_append_edge(e, vtarget);
|
||||
bmesh_disk_edge_append(e, vtarget);
|
||||
e = v->e;
|
||||
}
|
||||
|
||||
@ -1839,9 +1839,9 @@ static int bmesh_cutvert(BMesh *bm, BMVert *v, BMVert ***vout, int *len)
|
||||
}
|
||||
|
||||
BLI_assert(e->v1 == v || e->v2 == v);
|
||||
bmesh_disk_remove_edge(e, v);
|
||||
bmesh_disk_edge_remove(e, v);
|
||||
bmesh_edge_swapverts(e, v, verts[i]);
|
||||
bmesh_disk_append_edge(e, verts[i]);
|
||||
bmesh_disk_edge_append(e, verts[i]);
|
||||
}
|
||||
|
||||
BLI_ghash_free(visithash, NULL, NULL);
|
||||
@ -1884,7 +1884,7 @@ static int bmesh_edge_splice(BMesh *bm, BMEdge *e, BMEdge *etarget)
|
||||
l = e->l;
|
||||
BLI_assert(BM_vert_in_edge(etarget, l->v));
|
||||
BLI_assert(BM_vert_in_edge(etarget, l->next->v));
|
||||
bmesh_radial_remove_loop(l, e);
|
||||
bmesh_radial_loop_remove(l, e);
|
||||
bmesh_radial_append(etarget, l);
|
||||
}
|
||||
|
||||
@ -1927,7 +1927,7 @@ static int bmesh_cutedge(BMesh *bm, BMEdge *e, BMLoop *cutl)
|
||||
}
|
||||
|
||||
ne = BM_edge_create(bm, e->v1, e->v2, e, FALSE);
|
||||
bmesh_radial_remove_loop(cutl, e);
|
||||
bmesh_radial_loop_remove(cutl, e);
|
||||
bmesh_radial_append(ne, cutl);
|
||||
cutl->e = ne;
|
||||
|
||||
@ -1968,7 +1968,7 @@ static BMVert *bmesh_urmv_loop(BMesh *bm, BMLoop *sl)
|
||||
* will leave the original sv on some *other* fan (not the
|
||||
* one-face fan that holds the unglue face). */
|
||||
while (sv->e == sl->e || sv->e == sl->prev->e) {
|
||||
sv->e = bmesh_disk_nextedge(sv->e, sv);
|
||||
sv->e = bmesh_disk_edge_next(sv->e, sv);
|
||||
}
|
||||
|
||||
/* Split all fans connected to the vert, duplicating it for
|
||||
|
@ -166,7 +166,7 @@ void BMO_op_init(BMesh *bm, BMOperator *op, const char *opname)
|
||||
*
|
||||
* Executes a passed in operator. This handles
|
||||
* the allocation and freeing of temporary flag
|
||||
* layers and starting/stopping the modelling
|
||||
* layers and starting/stopping the modeling
|
||||
* loop. Can be called from other operators
|
||||
* exec callbacks as well.
|
||||
*/
|
||||
@ -859,7 +859,7 @@ int BMO_vert_edge_flags_count(BMesh *bm, BMVert *v, const short oflag)
|
||||
for (i = 0, curedge = v->e; i < len; i++) {
|
||||
if (BMO_elem_flag_test(bm, curedge, oflag))
|
||||
count++;
|
||||
curedge = bmesh_disk_nextedge(curedge, v);
|
||||
curedge = bmesh_disk_edge_next(curedge, v);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -218,7 +218,7 @@ int BM_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e)
|
||||
|
||||
BMVert *BM_edge_other_vert(BMEdge *e, BMVert *v)
|
||||
{
|
||||
return bmesh_edge_getothervert(e, v);
|
||||
return bmesh_edge_other_vert_get(e, v);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -247,7 +247,7 @@ int BM_edge_face_count(BMEdge *e)
|
||||
l_iter = e->l;
|
||||
do {
|
||||
count++;
|
||||
} while ((l_iter = bmesh_radial_nextloop(l_iter)) != e->l);
|
||||
} while ((l_iter = bmesh_radial_loop_next(l_iter)) != e->l);
|
||||
}
|
||||
|
||||
return count;
|
||||
@ -277,7 +277,7 @@ int BM_vert_face_count(BMVert *v)
|
||||
curedge = v->e;
|
||||
do {
|
||||
if (curedge->l) count += BM_edge_face_count(curedge);
|
||||
curedge = bmesh_disk_nextedge(curedge, v);
|
||||
curedge = bmesh_disk_edge_next(curedge, v);
|
||||
} while (curedge != v->e);
|
||||
}
|
||||
return count;
|
||||
@ -308,7 +308,7 @@ int BM_vert_is_wire(BMesh *UNUSED(bm), BMVert *v)
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
curedge = bmesh_disk_nextedge(curedge, v);
|
||||
curedge = bmesh_disk_edge_next(curedge, v);
|
||||
} while (curedge != v->e);
|
||||
|
||||
return TRUE;
|
||||
@ -355,7 +355,7 @@ int BM_vert_is_manifold(BMesh *UNUSED(bm), BMVert *v)
|
||||
|
||||
/* count edges while looking for non-manifold edges */
|
||||
oe = v->e;
|
||||
for (len = 0, e = v->e; e != oe || (e == oe && len == 0); len++, e = bmesh_disk_nextedge(e, v)) {
|
||||
for (len = 0, e = v->e; e != oe || (e == oe && len == 0); len++, e = bmesh_disk_edge_next(e, v)) {
|
||||
if (e->l == NULL) {
|
||||
/* loose edge */
|
||||
return FALSE;
|
||||
@ -461,7 +461,7 @@ int BM_face_share_edge_count(BMFace *f1, BMFace *f2)
|
||||
|
||||
l_iter = l_first = BM_FACE_FIRST_LOOP(f1);
|
||||
do {
|
||||
if (bmesh_radial_find_face(l_iter->e, f2)) {
|
||||
if (bmesh_radial_face_find(l_iter->e, f2)) {
|
||||
count++;
|
||||
}
|
||||
} while ((l_iter = l_iter->next) != l_first);
|
||||
@ -486,7 +486,7 @@ int BM_edge_share_face_count(BMEdge *e1, BMEdge *e2)
|
||||
l = e1->l;
|
||||
do {
|
||||
f = l->f;
|
||||
if (bmesh_radial_find_face(e2, f)) {
|
||||
if (bmesh_radial_face_find(e2, f)) {
|
||||
return TRUE;
|
||||
}
|
||||
l = l->radial_next;
|
||||
@ -616,9 +616,9 @@ float BM_vert_edge_angle(BMesh *UNUSED(bm), BMVert *v)
|
||||
* get the edges and count them both at once */
|
||||
|
||||
if ((e1 = v->e) &&
|
||||
(e2 = bmesh_disk_nextedge(e1, v)) &&
|
||||
(e2 = bmesh_disk_edge_next(e1, v)) &&
|
||||
/* make sure we come full circle and only have 2 connected edges */
|
||||
(e1 == bmesh_disk_nextedge(e2, v)))
|
||||
(e1 == bmesh_disk_edge_next(e2, v)))
|
||||
{
|
||||
BMVert *v1 = BM_edge_other_vert(e1, v);
|
||||
BMVert *v2 = BM_edge_other_vert(e2, v);
|
||||
|
@ -53,7 +53,7 @@ int bmesh_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e)
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
BMVert *bmesh_edge_getothervert(BMEdge *e, BMVert *v)
|
||||
BMVert *bmesh_edge_other_vert_get(BMEdge *e, BMVert *v)
|
||||
{
|
||||
if (e->v1 == v) {
|
||||
return e->v2;
|
||||
@ -112,10 +112,9 @@ int bmesh_edge_swapverts(BMEdge *e, BMVert *orig, BMVert *newv)
|
||||
*
|
||||
* Functions relating to this cycle:
|
||||
*
|
||||
* bmesh_disk_append_edge
|
||||
* bmesh_disk_remove_edge
|
||||
* bmesh_disk_nextedge
|
||||
* bmesh_disk_getpointer
|
||||
* bmesh_disk_edge_append
|
||||
* bmesh_disk_edge_remove
|
||||
* bmesh_disk_edge_next
|
||||
*
|
||||
* 2: The Radial Cycle - A circle of face edges (bmesh_Loop) around an edge
|
||||
* Base: edge->l->radial structure.
|
||||
@ -128,9 +127,9 @@ int bmesh_edge_swapverts(BMEdge *e, BMVert *orig, BMVert *newv)
|
||||
* Functions relating to this cycle:
|
||||
*
|
||||
* bmesh_radial_append
|
||||
* bmesh_radial_remove_loop
|
||||
* bmesh_radial_nextloop
|
||||
* bmesh_radial_find_face
|
||||
* bmesh_radial_loop_remove
|
||||
* bmesh_radial_loop_next
|
||||
* bmesh_radial_face_find
|
||||
*
|
||||
*
|
||||
* 3: The Loop Cycle - A circle of face edges around a polygon.
|
||||
@ -151,7 +150,7 @@ int bmesh_edge_swapverts(BMEdge *e, BMVert *orig, BMVert *newv)
|
||||
* cycle order and all non-manifold conditions are represented trivially.
|
||||
*
|
||||
*/
|
||||
int bmesh_disk_append_edge(struct BMEdge *e, struct BMVert *v)
|
||||
int bmesh_disk_edge_append(struct BMEdge *e, struct BMVert *v)
|
||||
{
|
||||
if (!v->e) {
|
||||
BMDiskLink *dl1 = BM_EDGE_DISK_LINK_GET(e, v);
|
||||
@ -177,7 +176,7 @@ int bmesh_disk_append_edge(struct BMEdge *e, struct BMVert *v)
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
void bmesh_disk_remove_edge(struct BMEdge *e, struct BMVert *v)
|
||||
void bmesh_disk_edge_remove(struct BMEdge *e, struct BMVert *v)
|
||||
{
|
||||
BMDiskLink *dl1, *dl2;
|
||||
|
||||
@ -199,7 +198,7 @@ void bmesh_disk_remove_edge(struct BMEdge *e, struct BMVert *v)
|
||||
}
|
||||
|
||||
/*
|
||||
* bmesh_disk_nextedge
|
||||
* bmesh_disk_edge_next
|
||||
*
|
||||
* Find the next edge in a disk cycle
|
||||
*
|
||||
@ -207,7 +206,7 @@ void bmesh_disk_remove_edge(struct BMEdge *e, struct BMVert *v)
|
||||
* Pointer to the next edge in the disk cycle for the vertex v.
|
||||
*/
|
||||
|
||||
struct BMEdge *bmesh_disk_nextedge(struct BMEdge *e, struct BMVert *v)
|
||||
struct BMEdge *bmesh_disk_edge_next(struct BMEdge *e, struct BMVert *v)
|
||||
{
|
||||
if (v == e->v1)
|
||||
return e->v1_disk_link.next;
|
||||
@ -225,7 +224,7 @@ static BMEdge *bmesh_disk_prevedge(BMEdge *e, BMVert *v)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
BMEdge *bmesh_disk_existedge(BMVert *v1, BMVert *v2)
|
||||
BMEdge *bmesh_disk_edge_exists(BMVert *v1, BMVert *v2)
|
||||
{
|
||||
BMEdge *curedge, *startedge;
|
||||
|
||||
@ -237,7 +236,7 @@ BMEdge *bmesh_disk_existedge(BMVert *v1, BMVert *v2)
|
||||
return curedge;
|
||||
}
|
||||
|
||||
curedge = bmesh_disk_nextedge(curedge, v1);
|
||||
curedge = bmesh_disk_edge_next(curedge, v1);
|
||||
} while (curedge != startedge);
|
||||
}
|
||||
|
||||
@ -258,7 +257,7 @@ int bmesh_disk_count(struct BMVert *v)
|
||||
return 0;
|
||||
}
|
||||
|
||||
e = bmesh_disk_nextedge(e, v);
|
||||
e = bmesh_disk_edge_next(e, v);
|
||||
|
||||
if (i >= (1 << 20)) {
|
||||
printf("bmesh error: infinite loop in disk cycle!\n");
|
||||
@ -286,7 +285,7 @@ int bmesh_disk_validate(int len, BMEdge *e, BMVert *v)
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
e2 = bmesh_disk_nextedge(e2, v);
|
||||
e2 = bmesh_disk_edge_next(e2, v);
|
||||
} while (e2 != e);
|
||||
|
||||
return TRUE;
|
||||
@ -301,7 +300,7 @@ int bmesh_disk_validate(int len, BMEdge *e, BMVert *v)
|
||||
* faces incident upon this vertex
|
||||
*/
|
||||
|
||||
int bmesh_disk_count_facevert(BMVert *v)
|
||||
int bmesh_disk_facevert_count(BMVert *v)
|
||||
{
|
||||
BMEdge *curedge;
|
||||
int count = 0;
|
||||
@ -313,8 +312,8 @@ int bmesh_disk_count_facevert(BMVert *v)
|
||||
/* first, loop around edge */
|
||||
curedge = v->e;
|
||||
do {
|
||||
if (curedge->l) count += bmesh_radial_count_facevert(curedge->l, v);
|
||||
curedge = bmesh_disk_nextedge(curedge, v);
|
||||
if (curedge->l) count += bmesh_radial_facevert_count(curedge->l, v);
|
||||
curedge = bmesh_disk_edge_next(curedge, v);
|
||||
} while (curedge != v->e);
|
||||
|
||||
return count;
|
||||
@ -329,30 +328,30 @@ int bmesh_disk_count_facevert(BMVert *v)
|
||||
* to it.
|
||||
*/
|
||||
|
||||
struct BMEdge *bmesh_disk_find_first_faceedge(struct BMEdge *e, struct BMVert *v)
|
||||
struct BMEdge *bmesh_disk_faceedge_find_first(struct BMEdge *e, struct BMVert *v)
|
||||
{
|
||||
BMEdge *searchedge = NULL;
|
||||
searchedge = e;
|
||||
do {
|
||||
if (searchedge->l && bmesh_radial_count_facevert(searchedge->l, v)) {
|
||||
if (searchedge->l && bmesh_radial_facevert_count(searchedge->l, v)) {
|
||||
return searchedge;
|
||||
}
|
||||
|
||||
searchedge = bmesh_disk_nextedge(searchedge, v);
|
||||
searchedge = bmesh_disk_edge_next(searchedge, v);
|
||||
} while (searchedge != e);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
struct BMEdge *bmesh_disk_find_next_faceedge(struct BMEdge *e, struct BMVert *v)
|
||||
struct BMEdge *bmesh_disk_faceedge_find_next(struct BMEdge *e, struct BMVert *v)
|
||||
{
|
||||
BMEdge *searchedge = NULL;
|
||||
searchedge = bmesh_disk_nextedge(e, v);
|
||||
searchedge = bmesh_disk_edge_next(e, v);
|
||||
do {
|
||||
if (searchedge->l && bmesh_radial_count_facevert(searchedge->l, v)) {
|
||||
if (searchedge->l && bmesh_radial_facevert_count(searchedge->l, v)) {
|
||||
return searchedge;
|
||||
}
|
||||
searchedge = bmesh_disk_nextedge(searchedge, v);
|
||||
searchedge = bmesh_disk_edge_next(searchedge, v);
|
||||
} while (searchedge != e);
|
||||
return e;
|
||||
}
|
||||
@ -383,7 +382,7 @@ int bmesh_radial_validate(int radlen, BMLoop *l)
|
||||
}
|
||||
|
||||
i++;
|
||||
} while ((l_iter = bmesh_radial_nextloop(l_iter)) != l);
|
||||
} while ((l_iter = bmesh_radial_loop_next(l_iter)) != l);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
@ -396,7 +395,7 @@ int bmesh_radial_validate(int radlen, BMLoop *l)
|
||||
* updated (in the case that the edge's link into the radial
|
||||
* cycle was the loop which is being removed from the cycle).
|
||||
*/
|
||||
void bmesh_radial_remove_loop(BMLoop *l, BMEdge *e)
|
||||
void bmesh_radial_loop_remove(BMLoop *l, BMEdge *e)
|
||||
{
|
||||
/* if e is non-NULL, l must be in the radial cycle of e */
|
||||
if (UNLIKELY(e && e != l->e)) {
|
||||
@ -434,7 +433,7 @@ void bmesh_radial_remove_loop(BMLoop *l, BMEdge *e)
|
||||
* Finds the first loop of v around radial
|
||||
* cycle
|
||||
*/
|
||||
BMLoop *bmesh_radial_find_first_faceloop(BMLoop *l, BMVert *v)
|
||||
BMLoop *bmesh_radial_faceloop_find_first(BMLoop *l, BMVert *v)
|
||||
{
|
||||
BMLoop *l_iter;
|
||||
l_iter = l;
|
||||
@ -442,23 +441,23 @@ BMLoop *bmesh_radial_find_first_faceloop(BMLoop *l, BMVert *v)
|
||||
if (l_iter->v == v) {
|
||||
return l_iter;
|
||||
}
|
||||
} while ((l_iter = bmesh_radial_nextloop(l_iter)) != l);
|
||||
} while ((l_iter = bmesh_radial_loop_next(l_iter)) != l);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
BMLoop *bmesh_radial_find_next_faceloop(BMLoop *l, BMVert *v)
|
||||
BMLoop *bmesh_radial_faceloop_find_next(BMLoop *l, BMVert *v)
|
||||
{
|
||||
BMLoop *l_iter;
|
||||
l_iter = bmesh_radial_nextloop(l);
|
||||
l_iter = bmesh_radial_loop_next(l);
|
||||
do {
|
||||
if (l_iter->v == v) {
|
||||
return l_iter;
|
||||
}
|
||||
} while ((l_iter = bmesh_radial_nextloop(l_iter)) != l);
|
||||
} while ((l_iter = bmesh_radial_loop_next(l_iter)) != l);
|
||||
return l;
|
||||
}
|
||||
|
||||
BMLoop *bmesh_radial_nextloop(BMLoop *l)
|
||||
BMLoop *bmesh_radial_loop_next(BMLoop *l)
|
||||
{
|
||||
return l->radial_next;
|
||||
}
|
||||
@ -512,7 +511,7 @@ void bmesh_radial_append(BMEdge *e, BMLoop *l)
|
||||
l->e = e;
|
||||
}
|
||||
|
||||
int bmesh_radial_find_face(BMEdge *e, BMFace *f)
|
||||
int bmesh_radial_face_find(BMEdge *e, BMFace *f)
|
||||
{
|
||||
BMLoop *l_iter;
|
||||
int i, len;
|
||||
@ -533,7 +532,7 @@ int bmesh_radial_find_face(BMEdge *e, BMFace *f)
|
||||
*
|
||||
*/
|
||||
|
||||
int bmesh_radial_count_facevert(BMLoop *l, BMVert *v)
|
||||
int bmesh_radial_facevert_count(BMLoop *l, BMVert *v)
|
||||
{
|
||||
BMLoop *l_iter;
|
||||
int count = 0;
|
||||
@ -542,7 +541,7 @@ int bmesh_radial_count_facevert(BMLoop *l, BMVert *v)
|
||||
if (l_iter->v == v) {
|
||||
count++;
|
||||
}
|
||||
} while ((l_iter = bmesh_radial_nextloop(l_iter)) != l);
|
||||
} while ((l_iter = bmesh_radial_loop_next(l_iter)) != l);
|
||||
|
||||
return count;
|
||||
}
|
||||
@ -584,131 +583,3 @@ int bmesh_loop_validate(BMFace *f)
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
#if 0
|
||||
|
||||
/**
|
||||
* bmesh_cycle_length
|
||||
*
|
||||
* Count the nodes in a cycle.
|
||||
*
|
||||
* Returns -
|
||||
* Integer
|
||||
*/
|
||||
|
||||
int bmesh_cycle_length(BMEdge *e, BMVert *v)
|
||||
{
|
||||
BMEdge *next, *prev, *cur;
|
||||
int len, vi = v == e->v1 ? 0 : 1;
|
||||
|
||||
/* should skip 2 forward if v is 1, happily reduces to (v * 2) */
|
||||
prev = *(&e->v1_prev + vi * 2);
|
||||
|
||||
cur = e;
|
||||
len = 1;
|
||||
while (cur != prev) {
|
||||
vi = cur->v1 == v ? 0 : 1;
|
||||
|
||||
len++;
|
||||
cur = *(&cur->v1_next + vi * 2);
|
||||
}
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
/* Begin Disk Cycle routine */
|
||||
|
||||
/**
|
||||
* bmesh_disk_getpointer
|
||||
*
|
||||
* Given an edge and one of its vertices, find the apporpriate CycleNode
|
||||
*
|
||||
* Returns -
|
||||
* Pointer to bmesh_CycleNode.
|
||||
*/
|
||||
BMNode *bmesh_disk_getpointer(BMEdge *e, BMVert *v)
|
||||
{
|
||||
/* returns pointer to the cycle node for the appropriate vertex in this dis */
|
||||
if (e->v1 == v) {
|
||||
return &(e->d1);
|
||||
}
|
||||
else if (e->v2 == v) {
|
||||
return &(e->d2);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* bmesh_disk_next_edgeflag
|
||||
*
|
||||
* Searches the disk cycle of v, starting with e, for the
|
||||
* next edge that has either eflag or tflag.
|
||||
*
|
||||
* bmesh_Edge pointer.
|
||||
*/
|
||||
|
||||
BMEdge *bmesh_disk_next_edgeflag(BMEdge *e, BMVert *v, int eflag, int tflag)
|
||||
{
|
||||
|
||||
BMNode *diskbase;
|
||||
BMEdge *curedge;
|
||||
int len, ok;
|
||||
|
||||
if (eflag && tflag) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ok = bmesh_vert_in_edge(e, v);
|
||||
if (ok) {
|
||||
diskbase = bmesh_disk_getpointer(e, v);
|
||||
len = bmesh_cycle_length(diskbase);
|
||||
curedge = bmesh_disk_nextedge(e, v);
|
||||
while (curedge != e) {
|
||||
if (eflag) {
|
||||
if (curedge->head.eflag1 == eflag) {
|
||||
return curedge;
|
||||
}
|
||||
}
|
||||
|
||||
curedge = bmesh_disk_nextedge(curedge, v);
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int bmesh_disk_hasedge(BMVert *v, BMEdge *e)
|
||||
{
|
||||
BMNode *diskbase;
|
||||
BMEdge *curedge;
|
||||
int i, len = 0;
|
||||
|
||||
if (v->e) {
|
||||
diskbase = bmesh_disk_getpointer(v->e, v);
|
||||
len = bmesh_cycle_length(diskbase);
|
||||
|
||||
for (i = 0, curedge = v->e; i < len; i++) {
|
||||
if (curedge == e) {
|
||||
return TRUE;
|
||||
}
|
||||
else curedge = bmesh_disk_nextedge(curedge, v);
|
||||
}
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
struct BMLoop *bmesh_loop_find_loop(struct BMFace *f, struct BMVert *v)
|
||||
{
|
||||
BMLoop *l;
|
||||
int i, len;
|
||||
|
||||
len = bmesh_cycle_length(f->lbase);
|
||||
for (i = 0, l = f->loopbase; i < len; i++, l = l->next) {
|
||||
if (l->v == v) {
|
||||
return l;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -41,61 +41,49 @@
|
||||
|
||||
struct ListBase;
|
||||
|
||||
/* DOUBLE CIRCULAR LINKED LIST FUNCTIONS */
|
||||
int bmesh_cycle_length(void *h);
|
||||
|
||||
/* LOOP CYCLE MANAGEMENT */
|
||||
int bmesh_loop_validate(BMFace *f);
|
||||
|
||||
/* DISK CYCLE MANAGMENT */
|
||||
int bmesh_disk_append_edge(struct BMEdge *e, struct BMVert *v);
|
||||
void bmesh_disk_remove_edge(struct BMEdge *e, struct BMVert *v);
|
||||
struct BMEdge *bmesh_disk_nextedge(struct BMEdge *e, struct BMVert *v);
|
||||
struct BMNode *bmesh_disk_getpointer(struct BMEdge *e, struct BMVert *v);
|
||||
int bmesh_disk_count_facevert(struct BMVert *v);
|
||||
struct BMEdge *bmesh_disk_find_first_faceedge(struct BMEdge *e, struct BMVert *v);
|
||||
struct BMEdge *bmesh_disk_find_next_faceedge(struct BMEdge *e, struct BMVert *v);
|
||||
int bmesh_disk_edge_append(BMEdge *e, BMVert *v);
|
||||
void bmesh_disk_edge_remove(BMEdge *e, BMVert *v);
|
||||
BMEdge *bmesh_disk_edge_next(BMEdge *e, BMVert *v);
|
||||
int bmesh_disk_facevert_count(BMVert *v);
|
||||
BMEdge *bmesh_disk_faceedge_find_first(BMEdge *e, BMVert *v);
|
||||
BMEdge *bmesh_disk_faceedge_find_next(BMEdge *e, BMVert *v);
|
||||
|
||||
/* RADIAL CYCLE MANAGMENT */
|
||||
void bmesh_radial_append(struct BMEdge *e, struct BMLoop *l);
|
||||
void bmesh_radial_remove_loop(struct BMLoop *l, struct BMEdge *e);
|
||||
int bmesh_radial_find_face(struct BMEdge *e, struct BMFace *f);
|
||||
struct BMLoop *bmesh_radial_nextloop(struct BMLoop *l);
|
||||
int bmesh_radial_count_facevert(struct BMLoop *l, struct BMVert *v);
|
||||
struct BMLoop *bmesh_radial_find_first_faceloop(struct BMLoop *l, struct BMVert *v);
|
||||
struct BMLoop *bmesh_radial_find_next_faceloop(struct BMLoop *l, struct BMVert *v);
|
||||
int bmesh_radial_validate(int radlen, struct BMLoop *l);
|
||||
void bmesh_radial_append(BMEdge *e, BMLoop *l);
|
||||
void bmesh_radial_loop_remove(BMLoop *l, BMEdge *e);
|
||||
int bmesh_radial_face_find(BMEdge *e, BMFace *f);
|
||||
BMLoop *bmesh_radial_loop_next(BMLoop *l);
|
||||
int bmesh_radial_facevert_count(BMLoop *l, BMVert *v);
|
||||
BMLoop *bmesh_radial_faceloop_find_first(BMLoop *l, BMVert *v);
|
||||
BMLoop *bmesh_radial_faceloop_find_next(BMLoop *l, BMVert *v);
|
||||
int bmesh_radial_validate(int radlen, BMLoop *l);
|
||||
|
||||
/* EDGE UTILITIES */
|
||||
int bmesh_vert_in_edge(struct BMEdge *e, struct BMVert *v);
|
||||
int bmesh_verts_in_edge(struct BMVert *v1, struct BMVert *v2, struct BMEdge *e);
|
||||
int bmesh_edge_swapverts(struct BMEdge *e, struct BMVert *orig, struct BMVert *newv); /*relink edge*/
|
||||
struct BMVert *bmesh_edge_getothervert(struct BMEdge *e, struct BMVert *v);
|
||||
struct BMEdge *bmesh_disk_existedge(BMVert *v1, BMVert *v2);
|
||||
struct BMEdge *bmesh_disk_next_edgeflag(struct BMEdge *e, struct BMVert *v, int eflag, int tflag);
|
||||
int bmesh_disk_validate(int len, struct BMEdge *e, struct BMVert *v);
|
||||
int bmesh_vert_in_edge(BMEdge *e, BMVert *v);
|
||||
int bmesh_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e);
|
||||
int bmesh_edge_swapverts(BMEdge *e, BMVert *orig, BMVert *newv); /*relink edge*/
|
||||
BMVert *bmesh_edge_other_vert_get(BMEdge *e, BMVert *v);
|
||||
BMEdge *bmesh_disk_edge_exists(BMVert *v1, BMVert *v2);
|
||||
int bmesh_disk_validate(int len, BMEdge *e, BMVert *v);
|
||||
|
||||
/*EULER API - For modifying structure*/
|
||||
struct BMVert *bmesh_mv(struct BMesh *bm, float *vec);
|
||||
struct BMEdge *bmesh_me(struct BMesh *bm, struct BMVert *v1, struct BMVert *v2);
|
||||
struct BMFace *bmesh_mf(struct BMesh *bm, struct BMVert *v1, struct BMVert *v2, struct BMEdge **elist, int len);
|
||||
int bmesh_kv(struct BMesh *bm, struct BMVert *v);
|
||||
int bmesh_ke(struct BMesh *bm, struct BMEdge *e);
|
||||
int bmesh_kf(struct BMesh *bm, struct BMFace *bply);
|
||||
struct BMVert *bmesh_semv(struct BMesh *bm, struct BMVert *tv, struct BMEdge *e, struct BMEdge **re);
|
||||
struct BMFace *bmesh_sfme(struct BMesh *bm, struct BMFace *f, struct BMVert *v1,
|
||||
struct BMVert *v2, struct BMLoop **rl,
|
||||
BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re);
|
||||
BMFace *bmesh_sfme(BMesh *bm, BMFace *f, BMVert *v1,
|
||||
BMVert *v2, BMLoop **rl,
|
||||
#ifdef USE_BMESH_HOLES
|
||||
ListBase *holes,
|
||||
#endif
|
||||
BMEdge *example
|
||||
);
|
||||
|
||||
struct BMEdge *bmesh_jekv(struct BMesh *bm, struct BMEdge *ke, struct BMVert *kv, const short check_edge_splice);
|
||||
int bmesh_loop_reverse(struct BMesh *bm, struct BMFace *f);
|
||||
struct BMFace *bmesh_jfke(struct BMesh *bm, struct BMFace *f1, struct BMFace *f2, struct BMEdge *e);
|
||||
BMEdge *bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv, const short check_edge_splice);
|
||||
int bmesh_loop_reverse(BMesh *bm, BMFace *f);
|
||||
BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e);
|
||||
|
||||
struct BMVert *bmesh_urmv(struct BMesh *bm, struct BMFace *sf, struct BMVert *sv);
|
||||
//int *bmesh_grkv(struct BMesh *bm, struct BMFace *sf, struct BMVert *kv);
|
||||
BMVert *bmesh_urmv(BMesh *bm, BMFace *sf, BMVert *sv);
|
||||
|
||||
#endif /* __BMESH_STRUCTURE_H__ */
|
||||
|
@ -157,7 +157,7 @@ static void *shellWalker_step(BMWalker *walker)
|
||||
newState->curedge = curedge;
|
||||
}
|
||||
}
|
||||
curedge = bmesh_disk_nextedge(curedge, shellWalk.base);
|
||||
curedge = bmesh_disk_edge_next(curedge, shellWalk.base);
|
||||
} while (curedge != shellWalk.curedge);
|
||||
|
||||
return shellWalk.curedge;
|
||||
@ -282,8 +282,8 @@ static void *islandboundWalker_step(BMWalker *walker)
|
||||
|
||||
while (1) {
|
||||
l = BM_face_other_loop(e, f, v);
|
||||
if (bmesh_radial_nextloop(l) != l) {
|
||||
l = bmesh_radial_nextloop(l);
|
||||
if (bmesh_radial_loop_next(l) != l) {
|
||||
l = bmesh_radial_loop_next(l);
|
||||
f = l->f;
|
||||
e = l->e;
|
||||
if (walker->mask_face && !BMO_elem_flag_test(walker->bm, f, walker->mask_face)) {
|
||||
@ -488,7 +488,7 @@ static void *loopWalker_step(BMWalker *walker)
|
||||
if (!l)
|
||||
break;
|
||||
|
||||
l2 = bmesh_radial_nextloop(l);
|
||||
l2 = bmesh_radial_loop_next(l);
|
||||
|
||||
if (l2 == l) {
|
||||
break;
|
||||
|
@ -53,7 +53,7 @@ static int UNUSED_FUNCTION(check_hole_in_region)(BMesh *bm, BMFace *f)
|
||||
for ( ; f2; f2 = BMW_step(®walker)) {
|
||||
l2 = BM_iter_new(&liter2, bm, BM_LOOPS_OF_FACE, f2);
|
||||
for ( ; l2; l2 = BM_iter_step(&liter2)) {
|
||||
l3 = bmesh_radial_nextloop(l2);
|
||||
l3 = bmesh_radial_loop_next(l2);
|
||||
if ( BMO_elem_flag_test(bm, l3->f, FACE_MARK) !=
|
||||
BMO_elem_flag_test(bm, l2->f, FACE_MARK))
|
||||
{
|
||||
@ -433,8 +433,8 @@ void dummy_exec(BMesh *bm, BMOperator *op)
|
||||
}
|
||||
|
||||
if (!found2) {
|
||||
bmesh_kf(bm, f);
|
||||
bmesh_ke(bm, fe);
|
||||
BM_face_kill(bm, f);
|
||||
BM_edge_kill(bm, fe);
|
||||
}
|
||||
} /* else if (f->len == 3) {
|
||||
BMEdge *ed[3];
|
||||
|
@ -152,7 +152,7 @@ static int BME_Bevel_Dissolve_Disk(BMesh *bm, BMVert *v)
|
||||
}
|
||||
|
||||
e = v->e;
|
||||
elast = bmesh_disk_nextedge(e, v);
|
||||
elast = bmesh_disk_edge_next(e, v);
|
||||
|
||||
/* BMESH_TODO, figure out if its possible we had a double edge here and need to splice it,
|
||||
* last bool arg */
|
||||
@ -274,7 +274,7 @@ static BMVert *BME_bevel_split_edge(BMesh *bm, BMVert *v, BMVert *v1, BMLoop *l,
|
||||
return NULL;
|
||||
}
|
||||
e1 = v->e; /* we just use the first two edges */
|
||||
e2 = bmesh_disk_nextedge(v->e, v);
|
||||
e2 = bmesh_disk_edge_next(v->e, v);
|
||||
if (e1 == e2) {
|
||||
//printf("You need at least two edges to use BME_bevel_split_edge()\n");
|
||||
return NULL;
|
||||
@ -459,7 +459,7 @@ static BMVert *BME_bevel_wire(BMesh *bm, BMVert *v, float value, int res, int UN
|
||||
BMVert *ov1, *ov2, *v1, *v2;
|
||||
|
||||
ov1 = BM_edge_other_vert(v->e, v);
|
||||
ov2 = BM_edge_other_vert(bmesh_disk_nextedge(v->e, v), v);
|
||||
ov2 = BM_edge_other_vert(bmesh_disk_edge_next(v->e, v), v);
|
||||
|
||||
/* split the edges */
|
||||
v1 = BME_bevel_split_edge(bm, v, ov1, NULL, NULL, value, td);
|
||||
@ -542,7 +542,7 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti
|
||||
/* find saved loop pointer */
|
||||
l = se->l;
|
||||
while (l->f != jf) {
|
||||
l = bmesh_radial_nextloop(l);
|
||||
l = bmesh_radial_loop_next(l);
|
||||
BLI_assert(l != se->l);
|
||||
}
|
||||
l = l->prev;
|
||||
@ -588,7 +588,7 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti
|
||||
/* find saved loop pointer */
|
||||
l = se->l;
|
||||
while (l->f != jf) {
|
||||
l = bmesh_radial_nextloop(l);
|
||||
l = bmesh_radial_loop_next(l);
|
||||
BLI_assert(l != se->l);
|
||||
}
|
||||
}
|
||||
@ -964,7 +964,7 @@ static BMesh *BME_bevel_mesh(BMesh *bm, float value, int UNUSED(res), int option
|
||||
BM_face_split(bm, l->f, l->next->v, l->prev->v, &l, l->e); /* clip this corner off */
|
||||
if(l2->f->len > 3)
|
||||
BM_face_split(bm, l2->f, l2->next->v, l2->prev->v, &l, l2->e); /* clip this corner off */
|
||||
curedge = bmesh_disk_nextedge(curedge, v);
|
||||
curedge = bmesh_disk_edge_next(curedge, v);
|
||||
} while(curedge != v->e);
|
||||
BME_Bevel_Dissolve_Disk(bm, v);
|
||||
}
|
||||
|
@ -38,10 +38,6 @@ extern "C" {
|
||||
struct ID;
|
||||
struct View3D;
|
||||
struct ARegion;
|
||||
struct EditMesh;
|
||||
struct EditVert;
|
||||
struct EditEdge;
|
||||
struct EditFace;
|
||||
struct bContext;
|
||||
struct wmOperator;
|
||||
struct wmWindowManager;
|
||||
|
@ -31,21 +31,20 @@
|
||||
#define __ED_UVEDIT_H__
|
||||
|
||||
struct ARegionType;
|
||||
struct EditFace;
|
||||
struct BMEditMesh;
|
||||
struct BMFace;
|
||||
struct BMLoop;
|
||||
struct Image;
|
||||
struct Main;
|
||||
struct ImageUser;
|
||||
struct MTFace;
|
||||
struct MTexPoly;
|
||||
struct Main;
|
||||
struct Object;
|
||||
struct Scene;
|
||||
struct SpaceImage;
|
||||
struct bContext;
|
||||
struct bNode;
|
||||
struct wmKeyConfig;
|
||||
struct BMEditMesh;
|
||||
struct BMLoop;
|
||||
struct BMFace;
|
||||
struct MTexPoly;
|
||||
|
||||
/* uvedit_ops.c */
|
||||
void ED_operatortypes_uvedit(void);
|
||||
|
@ -33,30 +33,29 @@
|
||||
|
||||
/* ********* exports for space_view3d/ module ********** */
|
||||
struct ARegion;
|
||||
struct bContext;
|
||||
struct BezTriple;
|
||||
struct bglMats;
|
||||
struct BoundBox;
|
||||
struct BPoint;
|
||||
struct Nurb;
|
||||
struct BezTriple;
|
||||
struct BMVert;
|
||||
struct BMEdge;
|
||||
struct BMFace;
|
||||
struct EditVert;
|
||||
struct BMVert;
|
||||
struct BPoint;
|
||||
struct BezTriple;
|
||||
struct BezTriple;
|
||||
struct BoundBox;
|
||||
struct ImBuf;
|
||||
struct MVert;
|
||||
struct Main;
|
||||
struct Nurb;
|
||||
struct Nurb;
|
||||
struct Object;
|
||||
struct rcti;
|
||||
struct RegionView3D;
|
||||
struct Scene;
|
||||
struct View3D;
|
||||
struct ViewContext;
|
||||
struct wmWindow;
|
||||
struct MVert;
|
||||
struct wmOperatorType;
|
||||
struct bContext;
|
||||
struct bglMats;
|
||||
struct rcti;
|
||||
struct wmOperator;
|
||||
struct wmOperatorType;
|
||||
struct wmWindow;
|
||||
|
||||
/* for derivedmesh drawing callbacks, for view3d_select, .... */
|
||||
typedef struct ViewContext {
|
||||
|
@ -2874,23 +2874,23 @@ typedef struct CutCurve {
|
||||
|
||||
/* ******************************************************************** */
|
||||
/* Knife Subdivide Tool. Subdivides edges intersected by a mouse trail
|
||||
drawn by user.
|
||||
|
||||
Currently mapped to KKey when in MeshEdit mode.
|
||||
Usage:
|
||||
Hit Shift K, Select Centers or Exact
|
||||
Hold LMB down to draw path, hit RETKEY.
|
||||
ESC cancels as expected.
|
||||
|
||||
Contributed by Robert Wenzlaff (Det. Thorn).
|
||||
|
||||
2.5 revamp:
|
||||
- non modal (no menu before cutting)
|
||||
- exit on mouse release
|
||||
- polygon/segment drawing can become handled by WM cb later
|
||||
|
||||
bmesh port version
|
||||
*/
|
||||
* drawn by user.
|
||||
*
|
||||
* Currently mapped to KKey when in MeshEdit mode.
|
||||
* Usage:
|
||||
* - Hit Shift K, Select Centers or Exact
|
||||
* - Hold LMB down to draw path, hit RETKEY.
|
||||
* - ESC cancels as expected.
|
||||
*
|
||||
* Contributed by Robert Wenzlaff (Det. Thorn).
|
||||
*
|
||||
* 2.5 Revamp:
|
||||
* - non modal (no menu before cutting)
|
||||
* - exit on mouse release
|
||||
* - polygon/segment drawing can become handled by WM cb later
|
||||
*
|
||||
* bmesh port version
|
||||
*/
|
||||
|
||||
#define KNIFE_EXACT 1
|
||||
#define KNIFE_MIDPOINT 2
|
||||
@ -2903,7 +2903,7 @@ static EnumPropertyItem knife_items[] = {
|
||||
{0, NULL, 0, NULL, NULL}
|
||||
};
|
||||
|
||||
/* seg_intersect() Determines if and where a mouse trail intersects an EditEdge */
|
||||
/* bm_edge_seg_isect() Determines if and where a mouse trail intersects an BMEdge */
|
||||
|
||||
static float bm_edge_seg_isect(BMEdge *e, CutCurve *c, int len, char mode,
|
||||
struct GHash *gh, int *isected)
|
||||
@ -3575,36 +3575,6 @@ void MESH_OT_dissolve_limited(wmOperatorType *ot)
|
||||
RNA_def_property_float_default(prop, DEG2RADF(15.0f));
|
||||
}
|
||||
|
||||
static int edge_flip_exec(bContext *UNUSED(C), wmOperator *UNUSED(op))
|
||||
{
|
||||
#if 0
|
||||
Object *obedit = CTX_data_edit_object(C);
|
||||
EditMesh *em = BKE_mesh_get_editmesh((Mesh *)obedit->data);
|
||||
|
||||
edge_flip(em);
|
||||
|
||||
DAG_id_tag_update(obedit->data, OB_RECALC_DATA);
|
||||
WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data);
|
||||
|
||||
BKE_mesh_end_editmesh(obedit->data, em);
|
||||
#endif
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
||||
void MESH_OT_edge_flip(wmOperatorType *ot)
|
||||
{
|
||||
/* identifiers */
|
||||
ot->name = "Edge Flip";
|
||||
ot->idname = "MESH_OT_edge_flip";
|
||||
|
||||
/* api callbacks */
|
||||
ot->exec = edge_flip_exec;
|
||||
ot->poll = ED_operator_editmesh;
|
||||
|
||||
/* flags */
|
||||
ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
|
||||
}
|
||||
|
||||
static int split_mesh_exec(bContext *C, wmOperator *op)
|
||||
{
|
||||
Object *ob = CTX_data_edit_object(C);
|
||||
|
@ -395,56 +395,6 @@ static int ringcut_cancel (bContext *C, wmOperator *op)
|
||||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
|
||||
/* for bmesh this tool is in bmesh_select.c */
|
||||
#if 0
|
||||
|
||||
static int ringsel_invoke (bContext *C, wmOperator *op, wmEvent *evt)
|
||||
{
|
||||
tringselOpData *lcd;
|
||||
EditEdge *edge;
|
||||
int dist = 75;
|
||||
|
||||
view3d_operator_needs_opengl(C);
|
||||
|
||||
if (!ringsel_init(C, op, 0))
|
||||
return OPERATOR_CANCELLED;
|
||||
|
||||
lcd = op->customdata;
|
||||
|
||||
if (lcd->em->selectmode == SCE_SELECT_FACE) {
|
||||
PointerRNA props_ptr;
|
||||
int extend = RNA_boolean_get(op->ptr, "extend");
|
||||
|
||||
ringsel_exit(op);
|
||||
|
||||
WM_operator_properties_create(&props_ptr, "MESH_OT_loop_select");
|
||||
RNA_boolean_set(&props_ptr, "extend", extend);
|
||||
WM_operator_name_call(C, "MESH_OT_loop_select", WM_OP_INVOKE_REGION_WIN, &props_ptr);
|
||||
WM_operator_properties_free(&props_ptr);
|
||||
|
||||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
|
||||
lcd->vc.mval[0] = evt->mval[0];
|
||||
lcd->vc.mval[1] = evt->mval[1];
|
||||
|
||||
edge = findnearestedge(&lcd->vc, &dist);
|
||||
if(!edge) {
|
||||
ringsel_exit(op);
|
||||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
|
||||
lcd->eed = edge;
|
||||
ringsel_find_edge(lcd, 1);
|
||||
|
||||
ringsel_finish(C, op);
|
||||
ringsel_exit(op);
|
||||
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
static int ringcut_invoke (bContext *C, wmOperator *op, wmEvent *evt)
|
||||
{
|
||||
Object *obedit= CTX_data_edit_object(C);
|
||||
|
@ -162,7 +162,6 @@ void MESH_OT_beautify_fill(struct wmOperatorType *ot);
|
||||
void MESH_OT_quads_convert_to_tris(struct wmOperatorType *ot);
|
||||
void MESH_OT_tris_convert_to_quads(struct wmOperatorType *ot);
|
||||
void MESH_OT_dissolve_limited(struct wmOperatorType *ot);
|
||||
void MESH_OT_edge_flip(struct wmOperatorType *ot);
|
||||
void MESH_OT_faces_shade_smooth(struct wmOperatorType *ot);
|
||||
void MESH_OT_faces_shade_flat(struct wmOperatorType *ot);
|
||||
void MESH_OT_split(struct wmOperatorType *ot);
|
||||
|
@ -115,7 +115,6 @@ void ED_operatortypes_mesh(void)
|
||||
WM_operatortype_append(MESH_OT_quads_convert_to_tris);
|
||||
WM_operatortype_append(MESH_OT_tris_convert_to_quads);
|
||||
WM_operatortype_append(MESH_OT_dissolve_limited);
|
||||
WM_operatortype_append(MESH_OT_edge_flip);
|
||||
WM_operatortype_append(MESH_OT_faces_shade_smooth);
|
||||
WM_operatortype_append(MESH_OT_faces_shade_flat);
|
||||
WM_operatortype_append(MESH_OT_sort_faces);
|
||||
@ -311,7 +310,6 @@ void ED_keymap_mesh(wmKeyConfig *keyconf)
|
||||
|
||||
WM_keymap_add_item(keymap, "MESH_OT_quads_convert_to_tris", TKEY, KM_PRESS, KM_CTRL, 0);
|
||||
WM_keymap_add_item(keymap, "MESH_OT_tris_convert_to_quads", JKEY, KM_PRESS, KM_ALT, 0);
|
||||
WM_keymap_add_item(keymap, "MESH_OT_edge_flip", FKEY, KM_PRESS, KM_SHIFT|KM_CTRL, 0);
|
||||
|
||||
WM_keymap_add_item(keymap, "MESH_OT_rip_move",VKEY, KM_PRESS, 0, 0);
|
||||
WM_keymap_add_item(keymap, "MESH_OT_merge", MKEY, KM_PRESS, KM_ALT, 0);
|
||||
|
@ -35,21 +35,20 @@
|
||||
|
||||
/* internal exports only */
|
||||
|
||||
struct bScreen;
|
||||
struct ARegion;
|
||||
struct BoundBox;
|
||||
struct Object;
|
||||
struct DerivedMesh;
|
||||
struct wmOperatorType;
|
||||
struct bContext;
|
||||
struct wmWindowManager;
|
||||
struct EditMesh;
|
||||
struct ViewContext;
|
||||
struct ARegionType;
|
||||
struct bPoseChannel;
|
||||
struct BoundBox;
|
||||
struct DerivedMesh;
|
||||
struct Object;
|
||||
struct ViewContext;
|
||||
struct bAnimVizSettings;
|
||||
struct bContext;
|
||||
struct bMotionPath;
|
||||
struct bPoseChannel;
|
||||
struct bScreen;
|
||||
struct wmNDOFMotionData;
|
||||
struct wmOperatorType;
|
||||
struct wmWindowManager;
|
||||
|
||||
#define BL_NEAR_CLIP 0.001
|
||||
|
||||
|
@ -567,6 +567,7 @@ static void do_lasso_select_mesh(ViewContext *vc, int mcords[][2], short moves,
|
||||
EDBM_selectmode_flush(vc->em);
|
||||
}
|
||||
|
||||
/* BMESH_TODO */
|
||||
#if 0
|
||||
/* this is an exception in that its the only lasso that dosnt use the 3d view (uses space image view) */
|
||||
static void do_lasso_select_mesh_uv(int mcords[][2], short moves, short select)
|
||||
|
@ -181,8 +181,6 @@ typedef struct TransDataNla {
|
||||
} TransDataNla;
|
||||
|
||||
struct LinkNode;
|
||||
struct EditEdge;
|
||||
struct EditVert;
|
||||
struct GHash;
|
||||
|
||||
typedef struct TransDataSlideVert {
|
||||
@ -202,13 +200,6 @@ typedef struct SlideData {
|
||||
struct SmallHash vhash;
|
||||
struct SmallHash origfaces;
|
||||
|
||||
/*
|
||||
TransDataSlideUv *slideuv, *suv_last;
|
||||
int totuv, uvlay_tot;
|
||||
struct GHash *vhash, **uvhash;
|
||||
struct EditVert *nearest;
|
||||
struct LinkNode *edgelist, *vertlist;
|
||||
*/
|
||||
int start[2], end[2];
|
||||
struct BMEditMesh *em;
|
||||
float perc;
|
||||
@ -230,7 +221,7 @@ typedef struct TransData {
|
||||
struct bConstraint *con; /* for objects/bones, the first constraint in its constraint stack */
|
||||
TransDataExtension *ext; /* for objects, poses. 1 single malloc per TransInfo! */
|
||||
TransDataCurveHandleFlags *hdata; /* for curves, stores handle flags for modification/cancel */
|
||||
void *extra; /* extra data (mirrored element pointer, in editmode mesh to EditVert) (editbone for roll fixing) (...) */
|
||||
void *extra; /* extra data (mirrored element pointer, in editmode mesh to BMVert) (editbone for roll fixing) (...) */
|
||||
int flag; /* Various flags */
|
||||
short protectflag; /* If set, copy of Object or PoseChannel protection */
|
||||
} TransData;
|
||||
|
@ -1980,8 +1980,7 @@ static void get_edge_center(float cent_r[3], BMesh *bm, BMVert *eve)
|
||||
}
|
||||
}
|
||||
|
||||
/* way to overwrite what data is edited with transform
|
||||
* static void VertsToTransData(TransData *td, EditVert *eve, BakeKey *key) */
|
||||
/* way to overwrite what data is edited with transform */
|
||||
static void VertsToTransData(TransInfo *t, TransData *td, BMEditMesh *em, BMVert *eve, float *bweight)
|
||||
{
|
||||
td->flag = 0;
|
||||
|
@ -32,8 +32,6 @@
|
||||
#ifndef __UVEDIT_INTERN_H__
|
||||
#define __UVEDIT_INTERN_H__
|
||||
|
||||
struct EditFace;
|
||||
struct EditMesh;
|
||||
struct MTexPoly;
|
||||
struct Image;
|
||||
struct MTFace;
|
||||
|
@ -39,25 +39,24 @@
|
||||
|
||||
#include "DNA_defs.h" /* USE_BMESH_FORWARD_COMPAT */
|
||||
|
||||
struct AnimData;
|
||||
struct DerivedMesh;
|
||||
struct Ipo;
|
||||
struct Key;
|
||||
struct Material;
|
||||
struct MVert;
|
||||
struct MCol;
|
||||
struct MEdge;
|
||||
struct MFace;
|
||||
struct MCol;
|
||||
struct MSticky;
|
||||
struct Mesh;
|
||||
struct OcInfo;
|
||||
struct MPoly;
|
||||
struct MTexPoly;
|
||||
struct MLoop;
|
||||
struct MLoopUV;
|
||||
struct MLoopCol;
|
||||
struct MLoopUV;
|
||||
struct MPoly;
|
||||
struct MSticky;
|
||||
struct MTexPoly;
|
||||
struct MVert;
|
||||
struct Material;
|
||||
struct Mesh;
|
||||
struct Multires;
|
||||
struct EditMesh;
|
||||
struct AnimData;
|
||||
struct OcInfo;
|
||||
|
||||
typedef struct Mesh {
|
||||
ID id;
|
||||
|
@ -33,7 +33,6 @@
|
||||
|
||||
struct CustomData;
|
||||
struct DerivedMesh;
|
||||
struct EditMesh;
|
||||
struct MDeformVert;
|
||||
struct ModifierData;
|
||||
struct Object;
|
||||
|
@ -230,7 +230,6 @@ static void wm_gesture_draw_circle(wmGesture *gt)
|
||||
static void draw_filled_lasso(wmGesture *gt)
|
||||
{
|
||||
ScanFillVert *v=NULL, *lastv=NULL, *firstv=NULL;
|
||||
/* EditEdge *e; */ /* UNUSED */
|
||||
ScanFillFace *efa;
|
||||
short *lasso= (short *)gt->customdata;
|
||||
int i;
|
||||
|
@ -38,32 +38,33 @@
|
||||
|
||||
struct ARegion;
|
||||
struct ARegionType;
|
||||
struct BMEditMesh;
|
||||
struct Base;
|
||||
struct Brush;
|
||||
struct bNodeTree;
|
||||
struct bNodeSocket;
|
||||
struct CSG_FaceIteratorDescriptor;
|
||||
struct CSG_VertexIteratorDescriptor;
|
||||
struct ChannelDriver;
|
||||
struct ColorBand;
|
||||
struct CurveMapping;
|
||||
struct Context;
|
||||
struct Curve;
|
||||
struct CurveMapping;
|
||||
struct DerivedMesh;
|
||||
struct EditBone;
|
||||
struct EditFace;
|
||||
struct EditMesh;
|
||||
struct EnvMap;
|
||||
struct ID;
|
||||
struct FCurve;
|
||||
struct Heap;
|
||||
struct HeapNode;
|
||||
struct ID;
|
||||
struct ImBuf;
|
||||
struct Image;
|
||||
struct ImageUser;
|
||||
struct KeyingSetInfo;
|
||||
struct KeyingSet;
|
||||
struct KeyingSetInfo;
|
||||
struct LOD_Decimation_Info;
|
||||
struct MCol;
|
||||
struct MTex;
|
||||
struct Main;
|
||||
struct Material;
|
||||
struct MCol;
|
||||
struct MenuType;
|
||||
struct Mesh;
|
||||
struct ModifierData;
|
||||
@ -79,21 +80,32 @@ struct RenderEngineType;
|
||||
struct RenderLayer;
|
||||
struct RenderResult;
|
||||
struct Scene;
|
||||
struct Scene;
|
||||
struct ScrArea;
|
||||
struct SculptSession;
|
||||
struct ShadeInput;
|
||||
struct ShadeResult;
|
||||
struct SmallHash;
|
||||
struct SmallHashIter;
|
||||
struct SpaceClip;
|
||||
struct SpaceImage;
|
||||
struct SpaceNode;
|
||||
struct Tex;
|
||||
struct TexResult;
|
||||
struct Text;
|
||||
struct ToolSettings;
|
||||
struct View3D;
|
||||
struct bAction;
|
||||
struct bArmature;
|
||||
struct bConstraint;
|
||||
struct bConstraintOb;
|
||||
struct bConstraintTarget;
|
||||
struct bContextDataResult;
|
||||
struct bNode;
|
||||
struct bNodeSocket;
|
||||
struct bNodeTree;
|
||||
struct bPoseChannel;
|
||||
struct bPythonConstraint;
|
||||
struct uiLayout;
|
||||
struct wmEvent;
|
||||
struct wmKeyConfig;
|
||||
@ -101,20 +113,6 @@ struct wmKeyMap;
|
||||
struct wmOperator;
|
||||
struct wmWindow;
|
||||
struct wmWindowManager;
|
||||
struct View3D;
|
||||
struct ToolSettings;
|
||||
struct bContextDataResult;
|
||||
struct bConstraintTarget;
|
||||
struct bPythonConstraint;
|
||||
struct bConstraintOb;
|
||||
struct Context;
|
||||
struct ChannelDriver;
|
||||
struct BMEditMesh;
|
||||
struct Heap;
|
||||
struct HeapNode;
|
||||
struct Scene;
|
||||
struct SmallHash;
|
||||
struct SmallHashIter;
|
||||
|
||||
/*new render funcs */
|
||||
void EDBM_selectmode_set(struct BMEditMesh *em) {}
|
||||
@ -258,7 +256,6 @@ void WM_keymap_restore_to_default(struct wmKeyMap *keymap){}
|
||||
void WM_keymap_restore_item_to_default(struct bContext *C, struct wmKeyMap *keymap, struct wmKeyMapItem *kmi){}
|
||||
void WM_keymap_properties_reset(struct wmKeyMapItem *kmi){}
|
||||
void WM_keyconfig_update_tag(struct wmKeyMap *keymap, struct wmKeyMapItem *kmi) {}
|
||||
int WM_keymap_user_init(struct wmWindowManager *wm, struct wmKeyMap *keymap) {return 0;}
|
||||
int WM_keymap_item_compare(struct wmKeyMapItem *k1, struct wmKeyMapItem *k2){return 0;}
|
||||
|
||||
|
||||
@ -355,7 +352,6 @@ void ED_nurb_set_spline_type(struct Nurb *nu, int type){}
|
||||
|
||||
void EM_selectmode_set(struct EditMesh *em){}
|
||||
int EM_texFaceCheck(struct EditMesh *em){return 0;}
|
||||
struct MTFace *EM_get_active_mtface(struct EditMesh *em, struct EditFace **act_efa, struct MCol **mcol, int sloopy){return (struct MTFace *)NULL;}
|
||||
void make_editMesh(struct Scene *scene, struct Object *ob){}
|
||||
void load_editMesh(struct Scene *scene, struct Object *ob){}
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user