kannonier8/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity

Code Cleanup:

Browse Source 
* 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:
Campbell Barton 2012-02-27 13:47:53 +00:00
parent 08b35cda7f
commit e17bf02c2d
35 changed files with 260 additions and 552 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
release/scripts/presets/keyconfig/maya.py
View File

@ -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.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.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.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.rip_move', 'V', 'PRESS')
kmi = km.keymap_items.new('mesh.merge', 'M', 'PRESS', alt=True) 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) kmi = km.keymap_items.new('transform.shrink_fatten', 'S', 'PRESS', ctrl=True, alt=True)

1
release/scripts/startup/bl_ui/space_view3d.py
View File

@ -1720,7 +1720,6 @@ class VIEW3D_MT_edit_mesh_faces(Menu):
layout.operator("mesh.quads_convert_to_tris") layout.operator("mesh.quads_convert_to_tris")
layout.operator("mesh.tris_convert_to_quads") layout.operator("mesh.tris_convert_to_quads")
layout.operator("mesh.edge_flip")
layout.separator() layout.separator()

15
source/blender/bmesh/bmesh.h
View File

@ -62,14 +62,7 @@ extern "C" {
*/ */
/*forward declarations*/ /*forward declarations*/
struct BMesh;
struct BMVert;
struct BMEdge;
struct BMFace;
struct BMLoop;
struct BMOperator;
struct Mesh; struct Mesh;
struct EditMesh;
/* /*
* BMHeader * 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.*/ * the nl member to a loop in the newly created edge.*/
BMFace *BM_face_split(BMesh *bm, BMFace *f, BMFace *BM_face_split(BMesh *bm, BMFace *f,
BMVert *v1, BMVert *v2, BMVert *v1, BMVert *v2,
struct BMLoop **nl, BMEdge *example); BMLoop **nl, BMEdge *example);
/* these 2 functions are very similar */ /* these 2 functions are very similar */
BMEdge* BM_vert_collapse_faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac, 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_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_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(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_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(BMesh *em, CustomData *data, int type);
void BM_data_layer_free_n(BMesh *bm, CustomData *data, int type, int n); 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); float BM_elem_float_data_get(CustomData *cd, void *element, int type);
void BM_elem_float_data_set(struct CustomData *cd, void *element, int type, const float val); void BM_elem_float_data_set(CustomData *cd, void *element, int type, const float val);
/* get the area of the face */ /* get the area of the face */
float BM_face_area_calc(BMesh *bm, BMFace *f); float BM_face_area_calc(BMesh *bm, BMFace *f);

19
source/blender/bmesh/bmesh_class.h
View File

@ -30,24 +30,23 @@
/* bmesh data structures */ /* bmesh data structures */
/* dissable holes for now, these are ifdef'd because they use more memory and cant be saved in DNA currently */ /* 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 BMesh;
struct BMVert; struct BMVert;
struct BMEdge; struct BMEdge;
struct BMLoop; struct BMLoop;
struct BMFace; struct BMFace;
struct BMFlagLayer;
struct BMLayerType;
struct BMSubClassLayer;
struct BLI_mempool; struct BLI_mempool;
struct Object; struct Object;
/*note: it is very important for BMHeader to start with two /* note: it is very important for BMHeader to start with two
pointers. this is a requirement of mempool's method of * pointers. this is a requirement of mempool's method of
iteration. * iteration.
*/ *
* hrm. it doesnt but stull works ok, remove the comment above? - campbell.
*/
typedef struct BMHeader { typedef struct BMHeader {
void *data; /* customdata layers */ void *data; /* customdata layers */
int index; /* notes: int index; /* notes:
@ -99,10 +98,10 @@ typedef struct BMLoop {
struct BMFace *f; struct BMFace *f;
struct BMLoop *radial_next, *radial_prev; struct BMLoop *radial_next, *radial_prev;
/* these were originally commented as private but are used all over the code */ /* these were originally commented as private but are used all over the code */
/* can't use ListBase API, due to head */ /* can't use ListBase API, due to head */
struct BMLoop *next, *prev; struct BMLoop *next, *prev; /* next/prev verts around the face */
} BMLoop; } BMLoop;
/* can cast BMFace/BMEdge/BMVert, but NOT BMLoop, since these dont have a flag layer */ /* can cast BMFace/BMEdge/BMVert, but NOT BMLoop, since these dont have a flag layer */

14
source/blender/bmesh/bmesh_iterators.h
View File

@ -94,11 +94,11 @@ extern const char bm_iter_itype_htype_map[BM_ITYPE_MAX];
typedef struct BMIter { typedef struct BMIter {
BLI_mempool_iter pooliter; BLI_mempool_iter pooliter;
struct BMVert *firstvert, *nextvert, *vdata; BMVert *firstvert, *nextvert, *vdata;
struct BMEdge *firstedge, *nextedge, *edata; BMEdge *firstedge, *nextedge, *edata;
struct BMLoop *firstloop, *nextloop, *ldata, *l; BMLoop *firstloop, *nextloop, *ldata, *l;
struct BMFace *firstpoly, *nextpoly, *pdata; BMFace *firstpoly, *nextpoly, *pdata;
struct BMesh *bm; BMesh *bm;
void (*begin)(struct BMIter *iter); void (*begin)(struct BMIter *iter);
void *(*step)(struct BMIter *iter); void *(*step)(struct BMIter *iter);
union { union {
@ -111,8 +111,8 @@ typedef struct BMIter {
char itype; char itype;
} BMIter; } BMIter;
void *BM_iter_at_index(struct BMesh *bm, const char itype, void *data, int index); void *BM_iter_at_index(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); int BM_iter_as_array(BMesh *bm, const char itype, void *data, void **array, const int len);
/* private for bmesh_iterators_inline.c */ /* private for bmesh_iterators_inline.c */
void bmiter__vert_of_mesh_begin(struct BMIter *iter); void bmiter__vert_of_mesh_begin(struct BMIter *iter);

12
source/blender/bmesh/bmesh_marking.h
View File

@ -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); void BM_face_hide_set(BMesh *bm, BMFace *f, int hide);
/* Selection code */ /* 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 */ /* 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 /* individual element select functions, BM_elem_select_set is a shortcut for these
* that automatically detects which one to use*/ * that automatically detects which one to use*/
void BM_vert_select_set(struct BMesh *bm, struct BMVert *v, int select); void BM_vert_select_set(BMesh *bm, BMVert *v, int select);
void BM_edge_select_set(struct BMesh *bm, struct BMEdge *e, int select); void BM_edge_select_set(BMesh *bm, BMEdge *e, int select);
void BM_face_select_set(struct BMesh *bm, struct BMFace *f, 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 */ /* 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 */ /* edit selection stuff */
void BM_active_face_set(BMesh *em, BMFace *f); void BM_active_face_set(BMesh *em, BMFace *f);

3
source/blender/bmesh/bmesh_operator_api.h
View File

@ -140,8 +140,7 @@ typedef struct BMOperator {
int slottype; int slottype;
int needflag; int needflag;
int flag; int flag;
struct BMOpSlot slots[BMO_OP_MAX_SLOTS]; struct BMOpSlot slots[BMO_OP_MAX_SLOTS]; void (*exec)(BMesh *bm, struct BMOperator *op);
void (*exec)(struct BMesh *bm, struct BMOperator *op);
MemArena *arena; MemArena *arena;
} BMOperator; } BMOperator;

3
source/blender/bmesh/bmesh_operators.h
View File

@ -93,10 +93,9 @@ extern int bmesh_total_ops;
* to get more useful information (such as the mapping from * to get more useful information (such as the mapping from
* original to new elements) you should run the dupe op manually.*/ * original to new elements) you should run the dupe op manually.*/
struct Object; struct Object;
struct EditMesh;
#if 0 #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 #endif
void BM_mesh_esubdivideflag(struct Object *obedit, BMesh *bm, int flag, float smooth, void BM_mesh_esubdivideflag(struct Object *obedit, BMesh *bm, int flag, float smooth,
float fractal, int beauty, int numcuts, int seltype, float fractal, int beauty, int numcuts, int seltype,

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

@ -205,7 +205,7 @@ BMFace *BM_face_create_ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, i
BLI_array_append(edges2, e); BLI_array_append(edges2, e);
do { 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)) { if (e2 != e && BM_ELEM_API_FLAG_TEST(e2, _FLAG_MF)) {
v = BM_edge_other_vert(e2, v); v = BM_edge_other_vert(e2, v);
break; break;

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

@ -197,7 +197,7 @@ void *bmiter__edge_of_vert_step(BMIter *iter)
BMEdge *current = iter->nextedge; BMEdge *current = iter->nextedge;
if (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; if (iter->nextedge == iter->firstedge) iter->nextedge = NULL;
@ -214,11 +214,11 @@ void bmiter__face_of_vert_begin(BMIter *iter)
init_iterator(iter); init_iterator(iter);
iter->count = 0; iter->count = 0;
if (iter->vdata->e) if (iter->vdata->e)
iter->count = bmesh_disk_count_facevert(iter->vdata); iter->count = bmesh_disk_facevert_count(iter->vdata);
if (iter->count) { 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->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; iter->nextloop = iter->firstloop;
} }
} }
@ -228,10 +228,10 @@ void *bmiter__face_of_vert_step(BMIter *iter)
if (iter->count && iter->nextloop) { if (iter->count && iter->nextloop) {
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) { if (iter->nextloop == iter->firstloop) {
iter->nextedge = bmesh_disk_find_next_faceedge(iter->nextedge, iter->vdata); iter->nextedge = bmesh_disk_faceedge_find_next(iter->nextedge, iter->vdata);
iter->firstloop = bmesh_radial_find_first_faceloop(iter->nextedge->l, iter->vdata); iter->firstloop = bmesh_radial_faceloop_find_first(iter->nextedge->l, iter->vdata);
iter->nextloop = iter->firstloop; iter->nextloop = iter->firstloop;
} }
} }
@ -252,11 +252,11 @@ void bmiter__loop_of_vert_begin(BMIter *iter)
init_iterator(iter); init_iterator(iter);
iter->count = 0; iter->count = 0;
if (iter->vdata->e) if (iter->vdata->e)
iter->count = bmesh_disk_count_facevert(iter->vdata); iter->count = bmesh_disk_facevert_count(iter->vdata);
if (iter->count) { 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->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; iter->nextloop = iter->firstloop;
} }
} }
@ -266,10 +266,10 @@ void *bmiter__loop_of_vert_step(BMIter *iter)
if (iter->count) { if (iter->count) {
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) { if (iter->nextloop == iter->firstloop) {
iter->nextedge = bmesh_disk_find_next_faceedge(iter->nextedge, iter->vdata); iter->nextedge = bmesh_disk_faceedge_find_next(iter->nextedge, iter->vdata);
iter->firstloop = bmesh_radial_find_first_faceloop(iter->nextedge->l, iter->vdata); iter->firstloop = bmesh_radial_faceloop_find_first(iter->nextedge->l, iter->vdata);
iter->nextloop = iter->firstloop; iter->nextloop = iter->firstloop;
} }
} }
@ -302,7 +302,7 @@ void *bmiter__loops_of_edge_step(BMIter *iter)
BMLoop *current = iter->nextloop; BMLoop *current = iter->nextloop;
if (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) if (iter->nextloop == iter->firstloop)
iter->nextloop = NULL; iter->nextloop = NULL;
@ -324,7 +324,7 @@ void bmiter__loops_of_loop_begin(BMIter *iter)
init_iterator(iter); init_iterator(iter);
iter->firstloop = l; iter->firstloop = l;
iter->nextloop = bmesh_radial_nextloop(iter->firstloop); iter->nextloop = bmesh_radial_loop_next(iter->firstloop);
if (iter->nextloop == iter->firstloop) if (iter->nextloop == iter->firstloop)
iter->nextloop = NULL; iter->nextloop = NULL;
@ -334,7 +334,7 @@ void *bmiter__loops_of_loop_step(BMIter *iter)
{ {
BMLoop *current = iter->nextloop; 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; if (iter->nextloop == iter->firstloop) iter->nextloop = NULL;
@ -364,7 +364,7 @@ void *bmiter__face_of_edge_step(BMIter *iter)
{ {
BMLoop *current = iter->nextloop; 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; if (iter->nextloop == iter->firstloop) iter->nextloop = NULL;

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

@ -56,7 +56,6 @@
* *
* *
*/ */
#if 1
int BM_vert_dissolve(BMesh *bm, BMVert *v) int BM_vert_dissolve(BMesh *bm, BMVert *v)
{ {
const int len = BM_vert_edge_count(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 */ /* v->e we keep, what else */
e = v->e; e = v->e;
do { do {
e = bmesh_disk_nextedge(e, v); e = bmesh_disk_edge_next(e, v);
if (!(BM_edge_share_face_count(e, v->e))) { if (!(BM_edge_share_face_count(e, v->e))) {
keepedge = e; keepedge = e;
baseedge = v->e; baseedge = v->e;
@ -174,7 +173,7 @@ int BM_disk_dissolve(BMesh *bm, BMVert *v)
done = 0; done = 0;
break; break;
} }
e = bmesh_disk_nextedge(e, v); e = bmesh_disk_edge_next(e, v);
} while (e != v->e); } while (e != v->e);
} }
@ -199,37 +198,6 @@ int BM_disk_dissolve(BMesh *bm, BMVert *v)
return TRUE; 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 * 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) const short join_faces, const short kill_degenerate_faces)
{ {
BMEdge *ne = NULL; BMEdge *ne = NULL;
BMVert *tv = bmesh_edge_getothervert(ke, kv); BMVert *tv = bmesh_edge_other_vert_get(ke, kv);
BMEdge *e2; BMEdge *e2;
BMVert *tv2; BMVert *tv2;
@ -450,7 +418,7 @@ BMEdge *BM_vert_collapse_faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac,
/* now interpolate the vertex data */ /* now interpolate the vertex data */
BM_data_interp_from_verts(bm, kv, tv, kv, fac); 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); tv2 = BM_edge_other_vert(e2, kv);
if (join_faces) { 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, /* in this case we want to keep all faces and not join them,
* rather just get rid of the veretex - see bug [#28645] */ * 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) { if (tv) {
BMEdge *e2 = bmesh_disk_nextedge(ke, kv); BMEdge *e2 = bmesh_disk_edge_next(ke, kv);
if (e2) { if (e2) {
BMVert *tv2 = BM_edge_other_vert(e2, kv); BMVert *tv2 = BM_edge_other_vert(e2, kv);
if (tv2) { 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); nv = bmesh_semv(bm, v, e, ne);
if (nv == NULL) { if (nv == NULL) {
return NULL; return NULL;

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

@ -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); CustomData_bmesh_set_default(&bm->edata, &e->head.data);
bmesh_disk_append_edge(e, e->v1); bmesh_disk_edge_append(e, e->v1);
bmesh_disk_append_edge(e, e->v2); bmesh_disk_edge_append(e, e->v2);
if (example) if (example)
BM_elem_attrs_copy(bm, bm, example, e); BM_elem_attrs_copy(bm, bm, example, e);
@ -577,7 +577,7 @@ void BM_face_kill(BMesh *bm, BMFace *f)
do { do {
l_next = l_iter->next; 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); bmesh_kill_only_loop(bm, l_iter);
} while ((l_iter = l_next) != l_first); } 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) void BM_edge_kill(BMesh *bm, BMEdge *e)
{ {
bmesh_disk_remove_edge(e, e->v1); bmesh_disk_edge_remove(e, e->v1);
bmesh_disk_remove_edge(e, e->v2); bmesh_disk_edge_remove(e, e->v2);
if (e->l) { if (e->l) {
BMLoop *l = e->l, *lnext, *startl = 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; e = v->e;
while (v->e) { while (v->e) {
nexte = bmesh_disk_nextedge(e, v); nexte = bmesh_disk_edge_next(e, v);
BM_edge_kill(bm, e); BM_edge_kill(bm, e);
e = nexte; 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) { for (i = 0, l_iter = l_first; i < len; i++, l_iter = l_iter->next) {
BMEdge *curedge = l_iter->e; BMEdge *curedge = l_iter->e;
bmesh_radial_remove_loop(l_iter, curedge); bmesh_radial_loop_remove(l_iter, curedge);
BLI_array_append(edar, 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; 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)) { if (UNLIKELY(c >= BM_LOOP_RADIAL_MAX)) {
BMESH_ASSERT(0); BMESH_ASSERT(0);
goto error; goto error;
@ -820,7 +820,7 @@ static int UNUSED_FUNCTION(count_flagged_disk)(BMVert *v, int flag)
do { do {
i += BM_ELEM_API_FLAG_TEST(e, flag) ? 1 : 0; 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); } while (e != v->e);
return i; return i;
@ -850,7 +850,7 @@ static int disk_is_flagged(BMVert *v, int flag)
l = l->radial_next; l = l->radial_next;
} while (l != e->l); } while (l != e->l);
e = bmesh_disk_nextedge(e, v); e = bmesh_disk_edge_next(e, v);
} while (e != v->e); } while (e != v->e);
return TRUE; 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) { if (bmesh_vert_in_edge(e, tv) == 0) {
return NULL; return NULL;
} }
ov = bmesh_edge_getothervert(e, tv); ov = bmesh_edge_other_vert_get(e, tv);
/* count valence of v1 */ /* count valence of v1 */
valence1 = bmesh_disk_count(ov); 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); nv = BM_vert_create(bm, tv->co, tv);
ne = BM_edge_create(bm, nv, tv, e, FALSE); ne = BM_edge_create(bm, nv, tv, e, FALSE);
bmesh_disk_remove_edge(ne, tv); bmesh_disk_edge_remove(ne, tv);
bmesh_disk_remove_edge(ne, nv); bmesh_disk_edge_remove(ne, nv);
/* remove e from v2's disk cycle */ /* 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 */ /* swap out tv for nv in e */
bmesh_edge_swapverts(e, tv, nv); bmesh_edge_swapverts(e, tv, nv);
/* add e to nv's disk cycl */ /* 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 */ /* 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 */ /* add ne to tv's disk cycl */
bmesh_disk_append_edge(ne, tv); bmesh_disk_edge_append(ne, tv);
/* verify disk cycle */ /* verify disk cycle */
edok = bmesh_disk_validate(valence1, ov->e, ov); 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 = nextl;
l->f->len++; l->f->len++;
nextl = nextl != nextl->radial_next ? nextl->radial_next : NULL; 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 = bmesh_create_loop(bm, NULL, NULL, l->f, l);
nl->prev = 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); len = bmesh_disk_count(kv);
if (len == 2) { if (len == 2) {
oe = bmesh_disk_nextedge(ke, kv); oe = bmesh_disk_edge_next(ke, kv);
tv = bmesh_edge_getothervert(ke, kv); tv = bmesh_edge_other_vert_get(ke, kv);
ov = bmesh_edge_getothervert(oe, kv); ov = bmesh_edge_other_vert_get(oe, kv);
halt = bmesh_verts_in_edge(kv, tv, oe); /* check for double edge */ halt = bmesh_verts_in_edge(kv, tv, oe); /* check for double edge */
if (halt) { 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 */ /* 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 */ /* relink oe->kv to be oe->t */
bmesh_edge_swapverts(oe, kv, tv); bmesh_edge_swapverts(oe, kv, tv);
/* append oe to tv's disk cycl */ /* 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 */ /* 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 */ /* deal with radial cycle of k */
radlen = bmesh_radial_length(ke->l); 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 cycl */ /* 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 */ /* relink loops and fix vertex pointer */
if (killoop->next->v == kv) { if (killoop->next->v == kv) {
killoop->next->v = tv; 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.. */ /* this should be wrapped into a bme_free_radial function to be used by bmesh_KF as well.. */
for (i = 0; i < radlen; i++) { for (i = 0; i < radlen; i++) {
loops[i] = killoop; loops[i] = killoop;
killoop = bmesh_radial_nextloop(killoop); killoop = bmesh_radial_loop_next(killoop);
} }
for (i = 0; i < radlen; i++) { for (i = 0; i < radlen; i++) {
bm->totloop--; bm->totloop--;
@ -1537,7 +1537,7 @@ struct BMEdge *bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv, const short check_e
BMESH_ASSERT(edok != FALSE); BMESH_ASSERT(edok != FALSE);
/* Validate loop cycle of all faces attached to o */ /* 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); BMESH_ASSERT(l->e == oe);
edok = bmesh_verts_in_edge(l->v, l->next->v, oe); edok = bmesh_verts_in_edge(l->v, l->next->v, oe);
BMESH_ASSERT(edok != FALSE); 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 /* validate that for each face, each vertex has another edge in its disk cycle that is
* not e, and not shared. */ * not e, and not shared. */
if ( bmesh_radial_find_face(f1loop->next->e, f2) || if ( bmesh_radial_face_find(f1loop->next->e, f2) ||
bmesh_radial_find_face(f1loop->prev->e, f2) || bmesh_radial_face_find(f1loop->prev->e, f2) ||
bmesh_radial_find_face(f2loop->next->e, f1) || bmesh_radial_face_find(f2loop->next->e, f1) ||
bmesh_radial_find_face(f2loop->prev->e, f1) ) bmesh_radial_face_find(f2loop->prev->e, f1) )
{ {
return NULL; return NULL;
} }
@ -1697,8 +1697,8 @@ BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e)
l_iter->f = f1; l_iter->f = f1;
/* remove edge from the disk cycle of its two vertices */ /* remove edge from the disk cycle of its two vertices */
bmesh_disk_remove_edge(f1loop->e, f1loop->e->v1); bmesh_disk_edge_remove(f1loop->e, f1loop->e->v1);
bmesh_disk_remove_edge(f1loop->e, f1loop->e->v2); bmesh_disk_edge_remove(f1loop->e, f1loop->e->v2);
/* deallocate edge and its two loops as well as f2 */ /* deallocate edge and its two loops as well as f2 */
BLI_mempool_free(bm->toolflagpool, f1loop->e->oflags); 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 */ /* move all the edges from v's disk to vtarget's disk */
e = v->e; e = v->e;
while (e != NULL) { while (e != NULL) {
bmesh_disk_remove_edge(e, v); bmesh_disk_edge_remove(e, v);
bmesh_edge_swapverts(e, v, vtarget); bmesh_edge_swapverts(e, v, vtarget);
bmesh_disk_append_edge(e, vtarget); bmesh_disk_edge_append(e, vtarget);
e = v->e; 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); 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_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); BLI_ghash_free(visithash, NULL, NULL);
@ -1884,7 +1884,7 @@ static int bmesh_edge_splice(BMesh *bm, BMEdge *e, BMEdge *etarget)
l = e->l; l = e->l;
BLI_assert(BM_vert_in_edge(etarget, l->v)); BLI_assert(BM_vert_in_edge(etarget, l->v));
BLI_assert(BM_vert_in_edge(etarget, l->next->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); 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); 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); bmesh_radial_append(ne, cutl);
cutl->e = ne; 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 * will leave the original sv on some *other* fan (not the
* one-face fan that holds the unglue face). */ * one-face fan that holds the unglue face). */
while (sv->e == sl->e || sv->e == sl->prev->e) { 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 /* Split all fans connected to the vert, duplicating it for

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

@ -166,7 +166,7 @@ void BMO_op_init(BMesh *bm, BMOperator *op, const char *opname)
* *
* Executes a passed in operator. This handles * Executes a passed in operator. This handles
* the allocation and freeing of temporary flag * 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 * loop. Can be called from other operators
* exec callbacks as well. * 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++) { for (i = 0, curedge = v->e; i < len; i++) {
if (BMO_elem_flag_test(bm, curedge, oflag)) if (BMO_elem_flag_test(bm, curedge, oflag))
count++; count++;
curedge = bmesh_disk_nextedge(curedge, v); curedge = bmesh_disk_edge_next(curedge, v);
} }
} }

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

@ -218,7 +218,7 @@ int BM_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e)
BMVert *BM_edge_other_vert(BMEdge *e, BMVert *v) 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; l_iter = e->l;
do { do {
count++; count++;
} while ((l_iter = bmesh_radial_nextloop(l_iter)) != e->l); } while ((l_iter = bmesh_radial_loop_next(l_iter)) != e->l);
} }
return count; return count;
@ -277,7 +277,7 @@ int BM_vert_face_count(BMVert *v)
curedge = v->e; curedge = v->e;
do { do {
if (curedge->l) count += BM_edge_face_count(curedge); 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); } while (curedge != v->e);
} }
return count; return count;
@ -308,7 +308,7 @@ int BM_vert_is_wire(BMesh *UNUSED(bm), BMVert *v)
return FALSE; return FALSE;
} }
curedge = bmesh_disk_nextedge(curedge, v); curedge = bmesh_disk_edge_next(curedge, v);
} while (curedge != v->e); } while (curedge != v->e);
return TRUE; return TRUE;
@ -355,7 +355,7 @@ int BM_vert_is_manifold(BMesh *UNUSED(bm), BMVert *v)
/* count edges while looking for non-manifold edges */ /* count edges while looking for non-manifold edges */
oe = v->e; 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) { if (e->l == NULL) {
/* loose edge */ /* loose edge */
return FALSE; 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); l_iter = l_first = BM_FACE_FIRST_LOOP(f1);
do { do {
if (bmesh_radial_find_face(l_iter->e, f2)) { if (bmesh_radial_face_find(l_iter->e, f2)) {
count++; count++;
} }
} while ((l_iter = l_iter->next) != l_first); } 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; l = e1->l;
do { do {
f = l->f; f = l->f;
if (bmesh_radial_find_face(e2, f)) { if (bmesh_radial_face_find(e2, f)) {
return TRUE; return TRUE;
} }
l = l->radial_next; 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 */ * get the edges and count them both at once */
if ((e1 = v->e) && 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 */ /* 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 *v1 = BM_edge_other_vert(e1, v);
BMVert *v2 = BM_edge_other_vert(e2, v); BMVert *v2 = BM_edge_other_vert(e2, v);

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

@ -53,7 +53,7 @@ int bmesh_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e)
return FALSE; return FALSE;
} }
BMVert *bmesh_edge_getothervert(BMEdge *e, BMVert *v) BMVert *bmesh_edge_other_vert_get(BMEdge *e, BMVert *v)
{ {
if (e->v1 == v) { if (e->v1 == v) {
return e->v2; return e->v2;
@ -112,10 +112,9 @@ int bmesh_edge_swapverts(BMEdge *e, BMVert *orig, BMVert *newv)
* *
* Functions relating to this cycle: * Functions relating to this cycle:
* *
* bmesh_disk_append_edge * bmesh_disk_edge_append
* bmesh_disk_remove_edge * bmesh_disk_edge_remove
* bmesh_disk_nextedge * bmesh_disk_edge_next
* bmesh_disk_getpointer
* *
* 2: The Radial Cycle - A circle of face edges (bmesh_Loop) around an edge * 2: The Radial Cycle - A circle of face edges (bmesh_Loop) around an edge
* Base: edge->l->radial structure. * Base: edge->l->radial structure.
@ -128,9 +127,9 @@ int bmesh_edge_swapverts(BMEdge *e, BMVert *orig, BMVert *newv)
* Functions relating to this cycle: * Functions relating to this cycle:
* *
* bmesh_radial_append * bmesh_radial_append
* bmesh_radial_remove_loop * bmesh_radial_loop_remove
* bmesh_radial_nextloop * bmesh_radial_loop_next
* bmesh_radial_find_face * bmesh_radial_face_find
* *
* *
* 3: The Loop Cycle - A circle of face edges around a polygon. * 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. * 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) { if (!v->e) {
BMDiskLink *dl1 = BM_EDGE_DISK_LINK_GET(e, v); 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; 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; 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 * 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. * 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) if (v == e->v1)
return e->v1_disk_link.next; return e->v1_disk_link.next;
@ -225,7 +224,7 @@ static BMEdge *bmesh_disk_prevedge(BMEdge *e, BMVert *v)
return NULL; return NULL;
} }
BMEdge *bmesh_disk_existedge(BMVert *v1, BMVert *v2) BMEdge *bmesh_disk_edge_exists(BMVert *v1, BMVert *v2)
{ {
BMEdge *curedge, *startedge; BMEdge *curedge, *startedge;
@ -237,7 +236,7 @@ BMEdge *bmesh_disk_existedge(BMVert *v1, BMVert *v2)
return curedge; return curedge;
} }
curedge = bmesh_disk_nextedge(curedge, v1); curedge = bmesh_disk_edge_next(curedge, v1);
} while (curedge != startedge); } while (curedge != startedge);
} }
@ -258,7 +257,7 @@ int bmesh_disk_count(struct BMVert *v)
return 0; return 0;
} }
e = bmesh_disk_nextedge(e, v); e = bmesh_disk_edge_next(e, v);
if (i >= (1 << 20)) { if (i >= (1 << 20)) {
printf("bmesh error: infinite loop in disk cycle!\n"); 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; return FALSE;
} }
e2 = bmesh_disk_nextedge(e2, v); e2 = bmesh_disk_edge_next(e2, v);
} while (e2 != e); } while (e2 != e);
return TRUE; return TRUE;
@ -301,7 +300,7 @@ int bmesh_disk_validate(int len, BMEdge *e, BMVert *v)
* faces incident upon this vertex * faces incident upon this vertex
*/ */
int bmesh_disk_count_facevert(BMVert *v) int bmesh_disk_facevert_count(BMVert *v)
{ {
BMEdge *curedge; BMEdge *curedge;
int count = 0; int count = 0;
@ -313,8 +312,8 @@ int bmesh_disk_count_facevert(BMVert *v)
/* first, loop around edge */ /* first, loop around edge */
curedge = v->e; curedge = v->e;
do { do {
if (curedge->l) count += bmesh_radial_count_facevert(curedge->l, v); if (curedge->l) count += bmesh_radial_facevert_count(curedge->l, v);
curedge = bmesh_disk_nextedge(curedge, v); curedge = bmesh_disk_edge_next(curedge, v);
} while (curedge != v->e); } while (curedge != v->e);
return count; return count;
@ -329,30 +328,30 @@ int bmesh_disk_count_facevert(BMVert *v)
* to it. * 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; BMEdge *searchedge = NULL;
searchedge = e; searchedge = e;
do { do {
if (searchedge->l && bmesh_radial_count_facevert(searchedge->l, v)) { if (searchedge->l && bmesh_radial_facevert_count(searchedge->l, v)) {
return searchedge; return searchedge;
} }
searchedge = bmesh_disk_nextedge(searchedge, v); searchedge = bmesh_disk_edge_next(searchedge, v);
} while (searchedge != e); } while (searchedge != e);
return NULL; 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; BMEdge *searchedge = NULL;
searchedge = bmesh_disk_nextedge(e, v); searchedge = bmesh_disk_edge_next(e, v);
do { do {
if (searchedge->l && bmesh_radial_count_facevert(searchedge->l, v)) { if (searchedge->l && bmesh_radial_facevert_count(searchedge->l, v)) {
return searchedge; return searchedge;
} }
searchedge = bmesh_disk_nextedge(searchedge, v); searchedge = bmesh_disk_edge_next(searchedge, v);
} while (searchedge != e); } while (searchedge != e);
return e; return e;
} }
@ -383,7 +382,7 @@ int bmesh_radial_validate(int radlen, BMLoop *l)
} }
i++; i++;
} while ((l_iter = bmesh_radial_nextloop(l_iter)) != l); } while ((l_iter = bmesh_radial_loop_next(l_iter)) != l);
return TRUE; 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 * updated (in the case that the edge's link into the radial
* cycle was the loop which is being removed from the cycle). * 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 e is non-NULL, l must be in the radial cycle of e */
if (UNLIKELY(e && e != l->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 * Finds the first loop of v around radial
* cycle * cycle
*/ */
BMLoop *bmesh_radial_find_first_faceloop(BMLoop *l, BMVert *v) BMLoop *bmesh_radial_faceloop_find_first(BMLoop *l, BMVert *v)
{ {
BMLoop *l_iter; BMLoop *l_iter;
l_iter = l; l_iter = l;
@ -442,23 +441,23 @@ BMLoop *bmesh_radial_find_first_faceloop(BMLoop *l, BMVert *v)
if (l_iter->v == v) { if (l_iter->v == v) {
return l_iter; return l_iter;
} }
} while ((l_iter = bmesh_radial_nextloop(l_iter)) != l); } while ((l_iter = bmesh_radial_loop_next(l_iter)) != l);
return NULL; 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; BMLoop *l_iter;
l_iter = bmesh_radial_nextloop(l); l_iter = bmesh_radial_loop_next(l);
do { do {
if (l_iter->v == v) { if (l_iter->v == v) {
return l_iter; return l_iter;
} }
} while ((l_iter = bmesh_radial_nextloop(l_iter)) != l); } while ((l_iter = bmesh_radial_loop_next(l_iter)) != l);
return l; return l;
} }
BMLoop *bmesh_radial_nextloop(BMLoop *l) BMLoop *bmesh_radial_loop_next(BMLoop *l)
{ {
return l->radial_next; return l->radial_next;
} }
@ -512,7 +511,7 @@ void bmesh_radial_append(BMEdge *e, BMLoop *l)
l->e = e; l->e = e;
} }
int bmesh_radial_find_face(BMEdge *e, BMFace *f) int bmesh_radial_face_find(BMEdge *e, BMFace *f)
{ {
BMLoop *l_iter; BMLoop *l_iter;
int i, len; 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; BMLoop *l_iter;
int count = 0; int count = 0;
@ -542,7 +541,7 @@ int bmesh_radial_count_facevert(BMLoop *l, BMVert *v)
if (l_iter->v == v) { if (l_iter->v == v) {
count++; count++;
} }
} while ((l_iter = bmesh_radial_nextloop(l_iter)) != l); } while ((l_iter = bmesh_radial_loop_next(l_iter)) != l);
return count; return count;
} }
@ -584,131 +583,3 @@ int bmesh_loop_validate(BMFace *f)
return TRUE; 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

66
source/blender/bmesh/intern/bmesh_structure.h
View File

@ -41,61 +41,49 @@
struct ListBase; struct ListBase;
/* DOUBLE CIRCULAR LINKED LIST FUNCTIONS */
int bmesh_cycle_length(void *h);
/* LOOP CYCLE MANAGEMENT */ /* LOOP CYCLE MANAGEMENT */
int bmesh_loop_validate(BMFace *f); int bmesh_loop_validate(BMFace *f);
/* DISK CYCLE MANAGMENT */ /* DISK CYCLE MANAGMENT */
int bmesh_disk_append_edge(struct BMEdge *e, struct BMVert *v); int bmesh_disk_edge_append(BMEdge *e, BMVert *v);
void bmesh_disk_remove_edge(struct BMEdge *e, struct BMVert *v); void bmesh_disk_edge_remove(BMEdge *e, BMVert *v);
struct BMEdge *bmesh_disk_nextedge(struct BMEdge *e, struct BMVert *v); BMEdge *bmesh_disk_edge_next(BMEdge *e, BMVert *v);
struct BMNode *bmesh_disk_getpointer(struct BMEdge *e, struct BMVert *v); int bmesh_disk_facevert_count(BMVert *v);
int bmesh_disk_count_facevert(struct BMVert *v); BMEdge *bmesh_disk_faceedge_find_first(BMEdge *e, BMVert *v);
struct BMEdge *bmesh_disk_find_first_faceedge(struct BMEdge *e, struct BMVert *v); BMEdge *bmesh_disk_faceedge_find_next(BMEdge *e, BMVert *v);
struct BMEdge *bmesh_disk_find_next_faceedge(struct BMEdge *e, struct BMVert *v);
/* RADIAL CYCLE MANAGMENT */ /* RADIAL CYCLE MANAGMENT */
void bmesh_radial_append(struct BMEdge *e, struct BMLoop *l); void bmesh_radial_append(BMEdge *e, BMLoop *l);
void bmesh_radial_remove_loop(struct BMLoop *l, struct BMEdge *e); void bmesh_radial_loop_remove(BMLoop *l, BMEdge *e);
int bmesh_radial_find_face(struct BMEdge *e, struct BMFace *f); int bmesh_radial_face_find(BMEdge *e, BMFace *f);
struct BMLoop *bmesh_radial_nextloop(struct BMLoop *l); BMLoop *bmesh_radial_loop_next(BMLoop *l);
int bmesh_radial_count_facevert(struct BMLoop *l, struct BMVert *v); int bmesh_radial_facevert_count(BMLoop *l, BMVert *v);
struct BMLoop *bmesh_radial_find_first_faceloop(struct BMLoop *l, struct BMVert *v); BMLoop *bmesh_radial_faceloop_find_first(BMLoop *l, BMVert *v);
struct BMLoop *bmesh_radial_find_next_faceloop(struct BMLoop *l, struct BMVert *v); BMLoop *bmesh_radial_faceloop_find_next(BMLoop *l, BMVert *v);
int bmesh_radial_validate(int radlen, struct BMLoop *l); int bmesh_radial_validate(int radlen, BMLoop *l);
/* EDGE UTILITIES */ /* EDGE UTILITIES */
int bmesh_vert_in_edge(struct BMEdge *e, struct BMVert *v); int bmesh_vert_in_edge(BMEdge *e, BMVert *v);
int bmesh_verts_in_edge(struct BMVert *v1, struct BMVert *v2, struct BMEdge *e); int bmesh_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e);
int bmesh_edge_swapverts(struct BMEdge *e, struct BMVert *orig, struct BMVert *newv); /*relink edge*/ int bmesh_edge_swapverts(BMEdge *e, BMVert *orig, BMVert *newv); /*relink edge*/
struct BMVert *bmesh_edge_getothervert(struct BMEdge *e, struct BMVert *v); BMVert *bmesh_edge_other_vert_get(BMEdge *e, BMVert *v);
struct BMEdge *bmesh_disk_existedge(BMVert *v1, BMVert *v2); BMEdge *bmesh_disk_edge_exists(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, BMEdge *e, BMVert *v);
int bmesh_disk_validate(int len, struct BMEdge *e, struct BMVert *v);
/*EULER API - For modifying structure*/ /*EULER API - For modifying structure*/
struct BMVert *bmesh_mv(struct BMesh *bm, float *vec); BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re);
struct BMEdge *bmesh_me(struct BMesh *bm, struct BMVert *v1, struct BMVert *v2); BMFace *bmesh_sfme(BMesh *bm, BMFace *f, BMVert *v1,
struct BMFace *bmesh_mf(struct BMesh *bm, struct BMVert *v1, struct BMVert *v2, struct BMEdge **elist, int len); BMVert *v2, BMLoop **rl,
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,
#ifdef USE_BMESH_HOLES #ifdef USE_BMESH_HOLES
ListBase *holes, ListBase *holes,
#endif #endif
BMEdge *example BMEdge *example
); );
struct BMEdge *bmesh_jekv(struct BMesh *bm, struct BMEdge *ke, struct BMVert *kv, const short check_edge_splice); BMEdge *bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv, const short check_edge_splice);
int bmesh_loop_reverse(struct BMesh *bm, struct BMFace *f); int bmesh_loop_reverse(BMesh *bm, BMFace *f);
struct BMFace *bmesh_jfke(struct BMesh *bm, struct BMFace *f1, struct BMFace *f2, struct BMEdge *e); BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e);
struct BMVert *bmesh_urmv(struct BMesh *bm, struct BMFace *sf, struct BMVert *sv); BMVert *bmesh_urmv(BMesh *bm, BMFace *sf, BMVert *sv);
//int *bmesh_grkv(struct BMesh *bm, struct BMFace *sf, struct BMVert *kv);
#endif /* __BMESH_STRUCTURE_H__ */ #endif /* __BMESH_STRUCTURE_H__ */

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

@ -157,7 +157,7 @@ static void *shellWalker_step(BMWalker *walker)
newState->curedge = curedge; newState->curedge = curedge;
} }
} }
curedge = bmesh_disk_nextedge(curedge, shellWalk.base); curedge = bmesh_disk_edge_next(curedge, shellWalk.base);
} while (curedge != shellWalk.curedge); } while (curedge != shellWalk.curedge);
return shellWalk.curedge; return shellWalk.curedge;
@ -282,8 +282,8 @@ static void *islandboundWalker_step(BMWalker *walker)
while (1) { while (1) {
l = BM_face_other_loop(e, f, v); l = BM_face_other_loop(e, f, v);
if (bmesh_radial_nextloop(l) != l) { if (bmesh_radial_loop_next(l) != l) {
l = bmesh_radial_nextloop(l); l = bmesh_radial_loop_next(l);
f = l->f; f = l->f;
e = l->e; e = l->e;
if (walker->mask_face && !BMO_elem_flag_test(walker->bm, f, walker->mask_face)) { 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) if (!l)
break; break;
l2 = bmesh_radial_nextloop(l); l2 = bmesh_radial_loop_next(l);
if (l2 == l) { if (l2 == l) {
break; break;

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

@ -53,7 +53,7 @@ static int UNUSED_FUNCTION(check_hole_in_region)(BMesh *bm, BMFace *f)
for ( ; f2; f2 = BMW_step(&regwalker)) { for ( ; f2; f2 = BMW_step(&regwalker)) {
l2 = BM_iter_new(&liter2, bm, BM_LOOPS_OF_FACE, f2); l2 = BM_iter_new(&liter2, bm, BM_LOOPS_OF_FACE, f2);
for ( ; l2; l2 = BM_iter_step(&liter2)) { 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) != if ( BMO_elem_flag_test(bm, l3->f, FACE_MARK) !=
BMO_elem_flag_test(bm, l2->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) { if (!found2) {
bmesh_kf(bm, f); BM_face_kill(bm, f);
bmesh_ke(bm, fe); BM_edge_kill(bm, fe);
} }
} /* else if (f->len == 3) { } /* else if (f->len == 3) {
BMEdge *ed[3]; BMEdge *ed[3];

12
source/blender/bmesh/tools/BME_bevel.c
View File

@ -152,7 +152,7 @@ static int BME_Bevel_Dissolve_Disk(BMesh *bm, BMVert *v)
} }
e = v->e; 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, /* BMESH_TODO, figure out if its possible we had a double edge here and need to splice it,
* last bool arg */ * last bool arg */
@ -274,7 +274,7 @@ static BMVert *BME_bevel_split_edge(BMesh *bm, BMVert *v, BMVert *v1, BMLoop *l,
return NULL; return NULL;
} }
e1 = v->e; /* we just use the first two edges */ 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) { if (e1 == e2) {
//printf("You need at least two edges to use BME_bevel_split_edge()\n"); //printf("You need at least two edges to use BME_bevel_split_edge()\n");
return NULL; 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; BMVert *ov1, *ov2, *v1, *v2;
ov1 = BM_edge_other_vert(v->e, v); 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 */ /* split the edges */
v1 = BME_bevel_split_edge(bm, v, ov1, NULL, NULL, value, td); 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 */ /* find saved loop pointer */
l = se->l; l = se->l;
while (l->f != jf) { while (l->f != jf) {
l = bmesh_radial_nextloop(l); l = bmesh_radial_loop_next(l);
BLI_assert(l != se->l); BLI_assert(l != se->l);
} }
l = l->prev; 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 */ /* find saved loop pointer */
l = se->l; l = se->l;
while (l->f != jf) { while (l->f != jf) {
l = bmesh_radial_nextloop(l); l = bmesh_radial_loop_next(l);
BLI_assert(l != se->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 */ BM_face_split(bm, l->f, l->next->v, l->prev->v, &l, l->e); /* clip this corner off */
if(l2->f->len > 3) if(l2->f->len > 3)
BM_face_split(bm, l2->f, l2->next->v, l2->prev->v, &l, l2->e); /* clip this corner off */ 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); } while(curedge != v->e);
BME_Bevel_Dissolve_Disk(bm, v); BME_Bevel_Dissolve_Disk(bm, v);
} }

4
source/blender/editors/include/ED_mesh.h
View File

@ -38,10 +38,6 @@ extern "C" {
struct ID; struct ID;
struct View3D; struct View3D;
struct ARegion; struct ARegion;
struct EditMesh;
struct EditVert;
struct EditEdge;
struct EditFace;
struct bContext; struct bContext;
struct wmOperator; struct wmOperator;
struct wmWindowManager; struct wmWindowManager;

11
source/blender/editors/include/ED_uvedit.h
View File

@ -31,21 +31,20 @@
#define __ED_UVEDIT_H__ #define __ED_UVEDIT_H__
struct ARegionType; struct ARegionType;
struct EditFace; struct BMEditMesh;
struct BMFace;
struct BMLoop;
struct Image; struct Image;
struct Main;
struct ImageUser; struct ImageUser;
struct MTFace; struct MTFace;
struct MTexPoly;
struct Main;
struct Object; struct Object;
struct Scene; struct Scene;
struct SpaceImage; struct SpaceImage;
struct bContext; struct bContext;
struct bNode; struct bNode;
struct wmKeyConfig; struct wmKeyConfig;
struct BMEditMesh;
struct BMLoop;
struct BMFace;
struct MTexPoly;
/* uvedit_ops.c */ /* uvedit_ops.c */
void ED_operatortypes_uvedit(void); void ED_operatortypes_uvedit(void);

25
source/blender/editors/include/ED_view3d.h
View File

@ -33,30 +33,29 @@
/* ********* exports for space_view3d/ module ********** */ /* ********* exports for space_view3d/ module ********** */
struct ARegion; struct ARegion;
struct bContext;
struct BezTriple;
struct bglMats;
struct BoundBox;
struct BPoint;
struct Nurb;
struct BezTriple;
struct BMVert;
struct BMEdge; struct BMEdge;
struct BMFace; struct BMFace;
struct EditVert; struct BMVert;
struct BPoint;
struct BezTriple;
struct BezTriple;
struct BoundBox;
struct ImBuf; struct ImBuf;
struct MVert;
struct Main; struct Main;
struct Nurb; struct Nurb;
struct Nurb;
struct Object; struct Object;
struct rcti;
struct RegionView3D; struct RegionView3D;
struct Scene; struct Scene;
struct View3D; struct View3D;
struct ViewContext; struct ViewContext;
struct wmWindow; struct bContext;
struct MVert; struct bglMats;
struct wmOperatorType; struct rcti;
struct wmOperator; struct wmOperator;
struct wmOperatorType;
struct wmWindow;
/* for derivedmesh drawing callbacks, for view3d_select, .... */ /* for derivedmesh drawing callbacks, for view3d_select, .... */
typedef struct ViewContext { typedef struct ViewContext {

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

@ -2874,23 +2874,23 @@ typedef struct CutCurve {
/* ******************************************************************** */ /* ******************************************************************** */
/* Knife Subdivide Tool. Subdivides edges intersected by a mouse trail /* Knife Subdivide Tool. Subdivides edges intersected by a mouse trail
drawn by user. * drawn by user.
*
Currently mapped to KKey when in MeshEdit mode. * Currently mapped to KKey when in MeshEdit mode.
Usage: * Usage:
Hit Shift K, Select Centers or Exact * - Hit Shift K, Select Centers or Exact
Hold LMB down to draw path, hit RETKEY. * - Hold LMB down to draw path, hit RETKEY.
ESC cancels as expected. * - ESC cancels as expected.
*
Contributed by Robert Wenzlaff (Det. Thorn). * Contributed by Robert Wenzlaff (Det. Thorn).
*
2.5 revamp: * 2.5 Revamp:
- non modal (no menu before cutting) * - non modal (no menu before cutting)
- exit on mouse release * - exit on mouse release
- polygon/segment drawing can become handled by WM cb later * - polygon/segment drawing can become handled by WM cb later
*
bmesh port version * bmesh port version
*/ */
#define KNIFE_EXACT 1 #define KNIFE_EXACT 1
#define KNIFE_MIDPOINT 2 #define KNIFE_MIDPOINT 2
@ -2903,7 +2903,7 @@ static EnumPropertyItem knife_items[] = {
{0, NULL, 0, NULL, NULL} {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, static float bm_edge_seg_isect(BMEdge *e, CutCurve *c, int len, char mode,
struct GHash *gh, int *isected) 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)); 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) static int split_mesh_exec(bContext *C, wmOperator *op)
{ {
Object *ob = CTX_data_edit_object(C); Object *ob = CTX_data_edit_object(C);

50
source/blender/editors/mesh/loopcut.c
View File

@ -395,56 +395,6 @@ static int ringcut_cancel (bContext *C, wmOperator *op)
return OPERATOR_CANCELLED; 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) static int ringcut_invoke (bContext *C, wmOperator *op, wmEvent *evt)
{ {
Object *obedit= CTX_data_edit_object(C); Object *obedit= CTX_data_edit_object(C);

1
source/blender/editors/mesh/mesh_intern.h
View File

@ -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_quads_convert_to_tris(struct wmOperatorType *ot);
void MESH_OT_tris_convert_to_quads(struct wmOperatorType *ot); void MESH_OT_tris_convert_to_quads(struct wmOperatorType *ot);
void MESH_OT_dissolve_limited(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_smooth(struct wmOperatorType *ot);
void MESH_OT_faces_shade_flat(struct wmOperatorType *ot); void MESH_OT_faces_shade_flat(struct wmOperatorType *ot);
void MESH_OT_split(struct wmOperatorType *ot); void MESH_OT_split(struct wmOperatorType *ot);

2
source/blender/editors/mesh/mesh_ops.c
View File

@ -115,7 +115,6 @@ void ED_operatortypes_mesh(void)
WM_operatortype_append(MESH_OT_quads_convert_to_tris); WM_operatortype_append(MESH_OT_quads_convert_to_tris);
WM_operatortype_append(MESH_OT_tris_convert_to_quads); WM_operatortype_append(MESH_OT_tris_convert_to_quads);
WM_operatortype_append(MESH_OT_dissolve_limited); 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_smooth);
WM_operatortype_append(MESH_OT_faces_shade_flat); WM_operatortype_append(MESH_OT_faces_shade_flat);
WM_operatortype_append(MESH_OT_sort_faces); 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_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_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_rip_move",VKEY, KM_PRESS, 0, 0);
WM_keymap_add_item(keymap, "MESH_OT_merge", MKEY, KM_PRESS, KM_ALT, 0); WM_keymap_add_item(keymap, "MESH_OT_merge", MKEY, KM_PRESS, KM_ALT, 0);

19
source/blender/editors/space_view3d/view3d_intern.h
View File

@ -35,21 +35,20 @@
/* internal exports only */ /* internal exports only */
struct bScreen;
struct ARegion; struct ARegion;
struct BoundBox;
struct Object;
struct DerivedMesh;
struct wmOperatorType;
struct bContext;
struct wmWindowManager;
struct EditMesh;
struct ViewContext;
struct ARegionType; struct ARegionType;
struct bPoseChannel; struct BoundBox;
struct DerivedMesh;
struct Object;
struct ViewContext;
struct bAnimVizSettings; struct bAnimVizSettings;
struct bContext;
struct bMotionPath; struct bMotionPath;
struct bPoseChannel;
struct bScreen;
struct wmNDOFMotionData; struct wmNDOFMotionData;
struct wmOperatorType;
struct wmWindowManager;
#define BL_NEAR_CLIP 0.001 #define BL_NEAR_CLIP 0.001

1
source/blender/editors/space_view3d/view3d_select.c
View File

@ -567,6 +567,7 @@ static void do_lasso_select_mesh(ViewContext *vc, int mcords[][2], short moves,
EDBM_selectmode_flush(vc->em); EDBM_selectmode_flush(vc->em);
} }
/* BMESH_TODO */
#if 0 #if 0
/* this is an exception in that its the only lasso that dosnt use the 3d view (uses space image view) */ /* 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) static void do_lasso_select_mesh_uv(int mcords[][2], short moves, short select)

15
source/blender/editors/transform/transform.h
View File

@ -181,8 +181,6 @@ typedef struct TransDataNla {
} TransDataNla; } TransDataNla;
struct LinkNode; struct LinkNode;
struct EditEdge;
struct EditVert;
struct GHash; struct GHash;
typedef struct TransDataSlideVert { typedef struct TransDataSlideVert {
@ -201,14 +199,7 @@ typedef struct SlideData {
struct SmallHash vhash; struct SmallHash vhash;
struct SmallHash origfaces; 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]; int start[2], end[2];
struct BMEditMesh *em; struct BMEditMesh *em;
float perc; float perc;
@ -230,8 +221,8 @@ typedef struct TransData {
struct bConstraint *con; /* for objects/bones, the first constraint in its constraint stack */ struct bConstraint *con; /* for objects/bones, the first constraint in its constraint stack */
TransDataExtension *ext; /* for objects, poses. 1 single malloc per TransInfo! */ TransDataExtension *ext; /* for objects, poses. 1 single malloc per TransInfo! */
TransDataCurveHandleFlags *hdata; /* for curves, stores handle flags for modification/cancel */ 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 */ int flag; /* Various flags */
short protectflag; /* If set, copy of Object or PoseChannel protection */ short protectflag; /* If set, copy of Object or PoseChannel protection */
} TransData; } TransData;

3
source/blender/editors/transform/transform_conversions.c
View File

@ -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 /* way to overwrite what data is edited with transform */
* static void VertsToTransData(TransData *td, EditVert *eve, BakeKey *key) */
static void VertsToTransData(TransInfo *t, TransData *td, BMEditMesh *em, BMVert *eve, float *bweight) static void VertsToTransData(TransInfo *t, TransData *td, BMEditMesh *em, BMVert *eve, float *bweight)
{ {
td->flag = 0; td->flag = 0;

2
source/blender/editors/uvedit/uvedit_intern.h
View File

@ -32,8 +32,6 @@
#ifndef __UVEDIT_INTERN_H__ #ifndef __UVEDIT_INTERN_H__
#define __UVEDIT_INTERN_H__ #define __UVEDIT_INTERN_H__
struct EditFace;
struct EditMesh;
struct MTexPoly; struct MTexPoly;
struct Image; struct Image;
struct MTFace; struct MTFace;

21
source/blender/makesdna/DNA_mesh_types.h
View File

@ -39,25 +39,24 @@
#include "DNA_defs.h" /* USE_BMESH_FORWARD_COMPAT */ #include "DNA_defs.h" /* USE_BMESH_FORWARD_COMPAT */
struct AnimData;
struct DerivedMesh; struct DerivedMesh;
struct Ipo; struct Ipo;
struct Key; struct Key;
struct Material; struct MCol;
struct MVert;
struct MEdge; struct MEdge;
struct MFace; struct MFace;
struct MCol;
struct MSticky;
struct Mesh;
struct OcInfo;
struct MPoly;
struct MTexPoly;
struct MLoop; struct MLoop;
struct MLoopUV;
struct MLoopCol; struct MLoopCol;
struct MLoopUV;
struct MPoly;
struct MSticky;
struct MTexPoly;
struct MVert;
struct Material;
struct Mesh;
struct Multires; struct Multires;
struct EditMesh; struct OcInfo;
struct AnimData;
typedef struct Mesh { typedef struct Mesh {
ID id; ID id;

1
source/blender/modifiers/intern/MOD_util.h
View File

@ -33,7 +33,6 @@
struct CustomData; struct CustomData;
struct DerivedMesh; struct DerivedMesh;
struct EditMesh;
struct MDeformVert; struct MDeformVert;
struct ModifierData; struct ModifierData;
struct Object; struct Object;

1
source/blender/windowmanager/intern/wm_gesture.c
View File

@ -230,7 +230,6 @@ static void wm_gesture_draw_circle(wmGesture *gt)
static void draw_filled_lasso(wmGesture *gt) static void draw_filled_lasso(wmGesture *gt)
{ {
ScanFillVert *v=NULL, *lastv=NULL, *firstv=NULL; ScanFillVert *v=NULL, *lastv=NULL, *firstv=NULL;
/* EditEdge *e; */ /* UNUSED */
ScanFillFace *efa; ScanFillFace *efa;
short *lasso= (short *)gt->customdata; short *lasso= (short *)gt->customdata;
int i; int i;

44
source/blenderplayer/bad_level_call_stubs/stubs.c
View File

@ -38,32 +38,33 @@
struct ARegion; struct ARegion;
struct ARegionType; struct ARegionType;
struct BMEditMesh;
struct Base; struct Base;
struct Brush; struct Brush;
struct bNodeTree;
struct bNodeSocket;
struct CSG_FaceIteratorDescriptor; struct CSG_FaceIteratorDescriptor;
struct CSG_VertexIteratorDescriptor; struct CSG_VertexIteratorDescriptor;
struct ChannelDriver;
struct ColorBand; struct ColorBand;
struct CurveMapping; struct Context;
struct Curve; struct Curve;
struct CurveMapping;
struct DerivedMesh; struct DerivedMesh;
struct EditBone; struct EditBone;
struct EditFace;
struct EditMesh;
struct EnvMap; struct EnvMap;
struct ID;
struct FCurve; struct FCurve;
struct Heap;
struct HeapNode;
struct ID;
struct ImBuf; struct ImBuf;
struct Image; struct Image;
struct ImageUser; struct ImageUser;
struct KeyingSetInfo;
struct KeyingSet; struct KeyingSet;
struct KeyingSetInfo;
struct LOD_Decimation_Info; struct LOD_Decimation_Info;
struct MCol;
struct MTex; struct MTex;
struct Main; struct Main;
struct Material; struct Material;
struct MCol;
struct MenuType; struct MenuType;
struct Mesh; struct Mesh;
struct ModifierData; struct ModifierData;
@ -79,21 +80,32 @@ struct RenderEngineType;
struct RenderLayer; struct RenderLayer;
struct RenderResult; struct RenderResult;
struct Scene; struct Scene;
struct Scene;
struct ScrArea; struct ScrArea;
struct SculptSession; struct SculptSession;
struct ShadeInput; struct ShadeInput;
struct ShadeResult; struct ShadeResult;
struct SmallHash;
struct SmallHashIter;
struct SpaceClip; struct SpaceClip;
struct SpaceImage; struct SpaceImage;
struct SpaceNode; struct SpaceNode;
struct Tex; struct Tex;
struct TexResult; struct TexResult;
struct Text; struct Text;
struct ToolSettings;
struct View3D;
struct bAction; struct bAction;
struct bArmature; struct bArmature;
struct bConstraint; struct bConstraint;
struct bConstraintOb;
struct bConstraintTarget;
struct bContextDataResult;
struct bNode; struct bNode;
struct bNodeSocket;
struct bNodeTree;
struct bPoseChannel; struct bPoseChannel;
struct bPythonConstraint;
struct uiLayout; struct uiLayout;
struct wmEvent; struct wmEvent;
struct wmKeyConfig; struct wmKeyConfig;
@ -101,20 +113,6 @@ struct wmKeyMap;
struct wmOperator; struct wmOperator;
struct wmWindow; struct wmWindow;
struct wmWindowManager; 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 */ /*new render funcs */
void EDBM_selectmode_set(struct BMEditMesh *em) {} 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_restore_item_to_default(struct bContext *C, struct wmKeyMap *keymap, struct wmKeyMapItem *kmi){}
void WM_keymap_properties_reset(struct wmKeyMapItem *kmi){} void WM_keymap_properties_reset(struct wmKeyMapItem *kmi){}
void WM_keyconfig_update_tag(struct wmKeyMap *keymap, 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;} 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){} void EM_selectmode_set(struct EditMesh *em){}
int EM_texFaceCheck(struct EditMesh *em){return 0;} 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 make_editMesh(struct Scene *scene, struct Object *ob){}
void load_editMesh(struct Scene *scene, struct Object *ob){} void load_editMesh(struct Scene *scene, struct Object *ob){}