diff --git a/source/blender/bmesh/bmesh_iterators.h b/source/blender/bmesh/bmesh_iterators.h index bc9f2b387e9..1f4d46ac775 100644 --- a/source/blender/bmesh/bmesh_iterators.h +++ b/source/blender/bmesh/bmesh_iterators.h @@ -16,23 +16,23 @@ /*Defines for passing to BMIter_New. "OF" can be substituted for "around" - so BM_VERTS_OF_FACE means "vertices + so BM_VERTS_OF_MESH_OF_FACE means "vertices around a face." */ /*these iterator over all elements of a specific type in the mesh.*/ -#define BM_VERTS 1 -#define BM_EDGES 2 -#define BM_FACES 3 +#define BM_VERTS_OF_MESH 1 +#define BM_EDGES_OF_MESH 2 +#define BM_FACES_OF_MESH 3 /*these are topological iterators.*/ -#define BM_EDGES_OF_VERT 4 -#define BM_FACES_OF_VERT 5 -#define BM_FACES_OF_EDGE 6 -#define BM_VERTS_OF_FACE 7 +#define BM_EDGES_OF_MESH_OF_VERT 4 +#define BM_FACES_OF_MESH_OF_VERT 5 +#define BM_FACES_OF_MESH_OF_EDGE 6 +#define BM_VERTS_OF_MESH_OF_FACE 7 #define BM_FACEVERTS_OF_FACE 8 -#define BM_EDGES_OF_FACE 9 +#define BM_EDGES_OF_MESH_OF_FACE 9 #define BM_LOOPS_OF_FACE 10 #define BM_LOOPS_OF_VERT 11 diff --git a/source/blender/bmesh/bmesh_operator_api.h b/source/blender/bmesh/bmesh_operator_api.h index cbfd07d8923..b30e526225e 100644 --- a/source/blender/bmesh/bmesh_operator_api.h +++ b/source/blender/bmesh/bmesh_operator_api.h @@ -42,19 +42,22 @@ some notes: struct GHashIterator; -#define BMOP_OPSLOT_INT 0 -#define BMOP_OPSLOT_FLT 1 -#define BMOP_OPSLOT_PNT 2 -#define BMOP_OPSLOT_VEC 6 +/*slot type arrays are terminated by the last member + having a slot type of 0.*/ +#define BMOP_OPSLOT_SENTINEL 0 +#define BMOP_OPSLOT_INT 1 +#define BMOP_OPSLOT_FLT 2 +#define BMOP_OPSLOT_PNT 3 +#define BMOP_OPSLOT_VEC 7 /*after BMOP_OPSLOT_VEC, everything is dynamically allocated arrays. we leave a space in the identifiers for future growth.*/ -#define BMOP_OPSLOT_ELEMENT_BUF 7 -#define BMOP_OPSLOT_MAPPING 8 -#define BMOP_OPSLOT_TYPES 9 +#define BMOP_OPSLOT_ELEMENT_BUF 8 +#define BMOP_OPSLOT_MAPPING 9 +#define BMOP_OPSLOT_TYPES 10 /*please ignore all these structures, don't touch them in tool code, except for when your defining an operator with BMOpDefine.*/ @@ -96,7 +99,6 @@ typedef struct BMOpDefine { char *name; slottype slottypes[BMOP_MAX_SLOTS]; void (*exec)(BMesh *bm, BMOperator *op); - int totslot; int flag; /*doesn't do anything right now*/ } BMOpDefine; @@ -106,7 +108,7 @@ typedef struct BMOpDefine { have it set directly. and never use BMO_Set_Pnt to pass in a list of edges or any arrays, really.*/ -void BMO_Init_Op(struct BMOperator *op, int opcode); +void BMO_Init_Op(struct BMOperator *op, char *opname); /*executes an operator, pushing and popping a new tool flag layer as appropriate.*/ @@ -160,7 +162,9 @@ int BMO_CountFlag(struct BMesh *bm, int flag, int type); /*executes an operator*/ int BMO_CallOpf(BMesh *bm, char *fmt, ...); -/*initializes, but doesn't execute an operator*/ +/*initializes, but doesn't execute an operator. this is so you can + gain access to the outputs of the operator. note that you have + to execute/finitsh (BMO_Exec_Op and BMO_Finish_Op) yourself.*/ int BMO_InitOpf(BMesh *bm, BMOperator *op, char *fmt, ...); /*va_list version, used to implement the above two functions, @@ -168,72 +172,77 @@ int BMO_InitOpf(BMesh *bm, BMOperator *op, char *fmt, ...); int BMO_VInitOpf(BMesh *bm, BMOperator *op, char *fmt, va_list vlist); /*get a point to a slot. this may be removed layer on from the public API.*/ -BMOpSlot *BMO_GetSlot(struct BMOperator *op, int slotcode); +BMOpSlot *BMO_GetSlot(struct BMOperator *op, char *slotname); /*copies the data of a slot from one operator to another. src and dst are the source/destination slot codes, respectively.*/ -void BMO_CopySlot(struct BMOperator *source_op, struct BMOperator *dest_op, int src, int dst); +void BMO_CopySlot(struct BMOperator *source_op, struct BMOperator *dest_op, + char *src, char *dst); -void BMO_Set_Float(struct BMOperator *op, int slotcode, float f); -void BMO_Set_Int(struct BMOperator *op, int slotcode, int i); +void BMO_Set_Float(struct BMOperator *op, char *slotname, float f); +float BMO_Get_Float(BMOperator *op, char *slotname); +void BMO_Set_Int(struct BMOperator *op, char *slotname, int i); +int BMO_Get_Int(BMOperator *op, char *slotname); /*don't pass in arrays that are supposed to map to elements this way. so, e.g. passing in list of floats per element in another slot is bad. passing in, e.g. pointer to an editmesh for the conversion operator is fine though.*/ -void BMO_Set_Pnt(struct BMOperator *op, int slotcode, void *p); -void BMO_Set_Vec(struct BMOperator *op, int slotcode, float *vec); +void BMO_Set_Pnt(struct BMOperator *op, char *slotname, void *p); +void *BMO_Get_Pnt(BMOperator *op, char *slotname); +void BMO_Set_Vec(struct BMOperator *op, char *slotname, float *vec); +void BMO_Get_Vec(BMOperator *op, char *slotname, float *vec_out); /*puts every element of type type (which is a bitmask) with tool flag flag, into a slot.*/ -void BMO_Flag_To_Slot(struct BMesh *bm, struct BMOperator *op, int slotcode, int flag, int type); +void BMO_Flag_To_Slot(struct BMesh *bm, struct BMOperator *op, char *slotname, int flag, int type); /*tool-flags all elements inside an element slot array with flag flag.*/ -void BMO_Flag_Buffer(struct BMesh *bm, struct BMOperator *op, int slotcode, int flag); +void BMO_Flag_Buffer(struct BMesh *bm, struct BMOperator *op, char *slotname, int flag); /*clears tool-flag flag from all elements inside a slot array.*/ -void BMO_Unflag_Buffer(struct BMesh *bm, struct BMOperator *op, int slotcode, int flag); +void BMO_Unflag_Buffer(struct BMesh *bm, struct BMOperator *op, char *slotname, int flag); /*puts every element of type type (which is a bitmask) with header flag flag, into a slot.*/ -void BMO_HeaderFlag_To_Slot(struct BMesh *bm, struct BMOperator *op, int slotcode, int flag, int type); +void BMO_HeaderFlag_To_Slot(struct BMesh *bm, struct BMOperator *op, char *slotname, int flag, int type); /*counts number of elements inside a slot array.*/ -int BMO_CountSlotBuf(struct BMesh *bm, struct BMOperator *op, int slotcode); +int BMO_CountSlotBuf(struct BMesh *bm, struct BMOperator *op, char *slotname); /*inserts a key/value mapping into a mapping slot. note that it copies the value, it doesn't store a reference to it.*/ -void BMO_Insert_Mapping(BMesh *bm, BMOperator *op, int slotcode, +void BMO_Insert_Mapping(BMesh *bm, BMOperator *op, char *slotname, void *element, void *data, int len); /*inserts a key/float mapping pair into a mapping slot.*/ -void BMO_Insert_MapFloat(BMesh *bm, BMOperator *op, int slotcode, +void BMO_Insert_MapFloat(BMesh *bm, BMOperator *op, char *slotname, void *element, float val); //returns 1 if the specified pointer is in the map. -int BMO_InMap(BMesh *bm, BMOperator *op, int slotcode, void *element); +int BMO_InMap(BMesh *bm, BMOperator *op, char *slotname, void *element); /*returns a point to the value of a specific key.*/ -void *BMO_Get_MapData(BMesh *bm, BMOperator *op, int slotcode, void *element); +void *BMO_Get_MapData(BMesh *bm, BMOperator *op, char *slotname, void *element); /*returns the float part of a key/float pair.*/ -float BMO_Get_MapFloat(BMesh *bm, BMOperator *op, int slotcode, void *element); +float BMO_Get_MapFloat(BMesh *bm, BMOperator *op, char *slotname, void *element); /*flags all elements in a mapping. note that the mapping must only have bmesh elements in it.*/ void BMO_Mapping_To_Flag(struct BMesh *bm, struct BMOperator *op, - int slotcode, int flag); + char *slotname, int flag); /*pointer versoins of BMO_Get_MapFloat and BMO_Insert_MapFloat. do NOT use these for non-operator-api-allocated memory! instead use BMO_Get_MapData and BMO_Insert_Mapping, which copies the data.*/ -void BMO_Insert_MapPointer(BMesh *bm, BMOperator *op, int slotcode, +void BMO_Insert_MapPointer(BMesh *bm, BMOperator *op, char *slotname, void *element, void *val); -void *BMO_Get_MapPointer(BMesh *bm, BMOperator *op, int slotcode, +void *BMO_Get_MapPointer(BMesh *bm, BMOperator *op, char *slotname, void *element); @@ -279,7 +288,7 @@ typedef struct BMOIter { } BMOIter; void *BMO_IterNew(BMOIter *iter, BMesh *bm, BMOperator *op, - int slotcode); + char *slotname); void *BMO_IterStep(BMOIter *iter); /*returns a pointer to the key value when iterating over mappings. diff --git a/source/blender/bmesh/bmesh_operators.h b/source/blender/bmesh/bmesh_operators.h index 6c43ff5c8e4..e7d801b9beb 100644 --- a/source/blender/bmesh/bmesh_operators.h +++ b/source/blender/bmesh/bmesh_operators.h @@ -1,182 +1,19 @@ #ifndef BM_OPERATORS_H #define BM_OPERATORS_H -/*slot names and operator names appear in comments next to/above tbeir - enumeration/define value*/ +/*--------defines/enumerations for specific operators-------*/ -/*------------begin operator defines (see bmesh_opdefines.c too)------------*/ - -/*split*/ -#define BMOP_SPLIT 0 - -/*the split operator. splits geometry from the mesh.*/ +/*del operator "context" slot values*/ enum { - BMOP_SPLIT_MULTIN, /*geom*/ - BMOP_SPLIT_MULTOUT, /*geomout*/ - - //bounding edges of split faces - BMOP_SPLIT_BOUNDS_EDGEMAP, /*boundarymap*/ - BMOP_SPLIT_ISOLATED_VERTS_MAP, /*isovertmap*/ - BMOP_SPLIT_TOTSLOT, + DEL_VERTS = 1, + DEL_EDGES, + DEL_ONLYFACES, + DEL_EDGESFACES, + DEL_FACES, + DEL_ALL , + DEL_ONLYTAGGED, }; -/*dupe*/ -#define BMOP_DUPE 1 - -/*duplicates input geometry, and creates a bounds mapping between old/new - edges along the boundary.*/ -enum { - BMOP_DUPE_MULTIN, /*geom*/ - BMOP_DUPE_ORIG, /*origout*/ - BMOP_DUPE_NEW, /*newout*/ - /*we need a map for verts duplicated not connected - to any faces, too.*/ - BMOP_DUPE_BOUNDS_EDGEMAP, /*boundarymap*/ - BMOP_DUPE_ISOLATED_VERTS_MAP, /*isovertmap*/ - BMOP_DUPE_TOTSLOT -}; - -/*del*/ -#define BMOP_DEL 2 - -/*deletes input geometry, using on of several deletion methods - specified by context.*/ -enum { - BMOP_DEL_MULTIN, /*geom*/ - BMOP_DEL_CONTEXT, /*context*/ - BMOP_DEL_TOTSLOT, -}; - -/*context slot values*/ -#define DEL_VERTS 1 -#define DEL_EDGES 2 -#define DEL_ONLYFACES 3 -#define DEL_EDGESFACES 4 -#define DEL_FACES 5 -#define DEL_ALL 6 -#define DEL_ONLYTAGGED 7 - -/*editmesh_to_bmesh*/ -#define BMOP_FROM_EDITMESH 3 - -/*editmesh->bmesh op*/ -enum { - BMOP_FROM_EDITMESH_EM, /*em*/ - - /*maps old elements to new ones. - coud do new elements to old too, - in the future*/ - BMOP_FROM_EDITMESH_MAP, - BMOP_FROM_EDITMESH_TOTSLOT, -}; - -/*bmesh_to_editmesh*/ -#define BMOP_TO_EDITMESH 4 - -/*bmesh->editmesh op*/ -enum { - BMOP_TO_EDITMESH_EMOUT, /*emout*/ - BMOP_TO_EDITMESH_TOTSLOT, -}; - -/*esubd*/ -#define BMOP_ESUBDIVIDE 5 - -/*edge subdivide op*/ -enum { - BMOP_ESUBDIVIDE_EDGES, /*edges*/ - BMOP_ESUBDIVIDE_NUMCUTS, /*numcuts*/ - - //beauty flag in esubdivide - BMOP_ESUBDIVIDE_FLAG, /*flag*/ - BMOP_ESUBDIVIDE_RADIUS, /*radius*/ - - BMOP_ESUBDIVIDE_CUSTOMFILL_FACEMAP, /*custompatterns*/ - BMOP_ESUBDIVIDE_PERCENT_EDGEMAP, /*edgepercents*/ - - /*inner verts/new faces of completely filled faces, e.g. - fully selected face.*/ - BMOP_ESUBDIVIDE_INNER_MULTOUT, /*outinner*/ - - /*new edges and vertices from splitting original edges, - doesn't include edges creating by connecting verts.*/ - BMOP_ESUBDIVIDE_SPLIT_MULTOUT, /*outsplit*/ - BMOP_ESUBDIVIDE_TOTSLOT, -}; -/* -SUBDIV_SELECT_INNER -SUBDIV_SELECT_ORIG -SUBDIV_SELECT_INNER_SEL -SUBDIV_SELECT_LOOPCUT -DOUBLEOPFILL -*/ - -/*triangulate*/ -#define BMOP_TRIANGULATE 6 - -/*triangle tesselator op*/ -enum { - BMOP_TRIANG_FACEIN, /*faces*/ - BMOP_TRIANG_NEW_EDGES, /*edgeout*/ - BMOP_TRIANG_NEW_FACES, /*faceout*/ - - /*facemap, maps new faces to old one. since triangulator - uses only split face, the original ngon face is still there, - though it's just another triangle now.*/ - BMOP_TRIANG_FACEMAP, - BMOP_TRIANG_TOTSLOT, -}; - -/*dissolvefaces*/ -#define BMOP_DISSOLVE_FACES 7 - -/*dissolve faces*/ -enum { - BMOP_DISFACES_FACEIN, - //list of faces that comprise regions of split faces - BMOP_DISFACES_REGIONOUT, - BMOP_DISFACES_TOTSLOT, -}; - -/*dissolveverts*/ -#define BMOP_DISSOLVE_VERTS 8 - -/*dissolve verts*/ -enum { - BMOP_DISVERTS_VERTIN, /*verts*/ - BMOP_DISVERTS_TOTSLOT, -}; - -/*makefgon*/ -#define BMOP_MAKE_FGONS 9 - -#define BMOP_MAKE_FGONS_TOTSLOT 0 - -/*extrudefaceregion*/ -#define BMOP_EXTRUDE_EDGECONTEXT 10 -enum { - BMOP_EXFACE_EDGEFACEIN, /*edgefacein*/ - - //exclude edges from skirt connecting - BMOP_EXFACE_EXCLUDEMAP, /*exclude*/ - - //new geometry - BMOP_EXFACE_MULTOUT, /*geomout*/ - BMOP_EXFACE_TOTSLOT, -}; - -/*connectverts*/ -#define BMOP_CONNECT_VERTS 11 -enum { - BM_CONVERTS_VERTIN, /*verts*/ - BM_CONVERTS_EDGEOUT, /*edgeout*/ - BM_CONVERTS_TOTSLOT -}; - -/*keep this updated!*/ -#define BMOP_TOTAL_OPS 12 -/*-------------------------------end operator defines------------------------*/ - extern BMOpDefine *opdefines[]; extern int bmesh_total_ops; diff --git a/source/blender/bmesh/bmesh_queries.h b/source/blender/bmesh/bmesh_queries.h index a20d5e98650..10662251e05 100644 --- a/source/blender/bmesh/bmesh_queries.h +++ b/source/blender/bmesh/bmesh_queries.h @@ -12,12 +12,12 @@ int BM_Vert_In_Edge(struct BMEdge *e, struct BMVert *v); /*returns true if v is in f*/ int BM_Vert_In_Face(struct BMFace *f, struct BMVert *v); -// int BM_Verts_In_Face(struct BMFace *f, struct BMVert **varr, int len); -int BM_Verts_In_Face(struct BMesh *bm, struct BMFace *f, struct BMVert **varr, int len); +// int BM_VERTS_OF_MESH_In_Face(struct BMFace *f, struct BMVert **varr, int len); +int BM_VERTS_OF_MESH_In_Face(struct BMesh *bm, struct BMFace *f, struct BMVert **varr, int len); int BM_Edge_In_Face(struct BMFace *f, struct BMEdge *e); -int BM_Verts_In_Edge(struct BMVert *v1, struct BMVert *v2, BMEdge *e); +int BM_VERTS_OF_MESH_In_Edge(struct BMVert *v1, struct BMVert *v2, BMEdge *e); /*get opposing vert from v in edge e.*/ diff --git a/source/blender/bmesh/intern/bmesh_iterators.c b/source/blender/bmesh/intern/bmesh_iterators.c index 19b5e88e5bd..1cec582e9af 100644 --- a/source/blender/bmesh/intern/bmesh_iterators.c +++ b/source/blender/bmesh/intern/bmesh_iterators.c @@ -358,42 +358,42 @@ void *BMIter_New(BMIter *iter, BMesh *bm, int type, void *data) iter->bm = bm; switch(type){ - case BM_VERTS: + case BM_VERTS_OF_MESH: iter->begin = vert_of_mesh_begin; iter->step = vert_of_mesh_step; iter->bm = bm; break; - case BM_EDGES: + case BM_EDGES_OF_MESH: iter->begin = edge_of_mesh_begin; iter->step = edge_of_mesh_step; iter->bm = bm; break; - case BM_FACES: + case BM_FACES_OF_MESH: iter->begin = face_of_mesh_begin; iter->step = face_of_mesh_step; iter->bm = bm; break; - case BM_EDGES_OF_VERT: + case BM_EDGES_OF_MESH_OF_VERT: iter->begin = edge_of_vert_begin; iter->step = edge_of_vert_step; iter->vdata = data; break; - case BM_FACES_OF_VERT: + case BM_FACES_OF_MESH_OF_VERT: iter->begin = face_of_vert_begin; iter->step = face_of_vert_step; iter->vdata = data; break; - case BM_FACES_OF_EDGE: + case BM_FACES_OF_MESH_OF_EDGE: iter->begin = face_of_edge_begin; iter->step = face_of_edge_step; iter->edata = data; break; - case BM_VERTS_OF_FACE: + case BM_VERTS_OF_MESH_OF_FACE: iter->begin = vert_of_face_begin; iter->step = vert_of_face_step; iter->pdata = data; break; - case BM_EDGES_OF_FACE: + case BM_EDGES_OF_MESH_OF_FACE: iter->begin = edge_of_face_begin; iter->step = edge_of_face_step; iter->pdata = data; diff --git a/source/blender/bmesh/intern/bmesh_marking.c b/source/blender/bmesh/intern/bmesh_marking.c index 8f6bfad03d3..8d76ca21dc6 100644 --- a/source/blender/bmesh/intern/bmesh_marking.c +++ b/source/blender/bmesh/intern/bmesh_marking.c @@ -39,11 +39,11 @@ void bmesh_selectmode_flush(BMesh *bm) int totsel; if(bm->selectmode & BM_VERT){ - for(e = BMIter_New(&edges, bm, BM_EDGES, bm ); e; e= BMIter_Step(&edges)){ + for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm ); e; e= BMIter_Step(&edges)){ if(bmesh_test_sysflag(&(e->v1->head), BM_SELECT) && bmesh_test_sysflag(&(e->v2->head), BM_SELECT)) bmesh_set_sysflag(&(e->head), BM_SELECT); else bmesh_clear_sysflag(&(e->head), BM_SELECT); } - for(f = BMIter_New(&faces, bm, BM_FACES, bm ); f; f= BMIter_Step(&faces)){ + for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm ); f; f= BMIter_Step(&faces)){ totsel = 0; l=f->loopbase; do{ @@ -59,7 +59,7 @@ void bmesh_selectmode_flush(BMesh *bm) } } else if(bm->selectmode & BM_EDGE) { - for(f = BMIter_New(&faces, bm, BM_FACES, bm ); f; f= BMIter_Step(&faces)){ + for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm ); f; f= BMIter_Step(&faces)){ totsel = 0; l=f->loopbase; do{ @@ -174,25 +174,25 @@ void BM_Selectmode_Set(BMesh *bm, int selectmode) bm->selectmode = selectmode; if(bm->selectmode & BM_VERT){ - for(e = BMIter_New(&edges, bm, BM_EDGES, bm ); e; e= BMIter_Step(&edges)) + for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm ); e; e= BMIter_Step(&edges)) BM_Select_Edge(bm, e, 0); - for(f = BMIter_New(&faces, bm, BM_FACES, bm ); f; f= BMIter_Step(&faces)) + for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm ); f; f= BMIter_Step(&faces)) bmesh_clear_sysflag(&(f->head), 0); bmesh_selectmode_flush(bm); } else if(bm->selectmode & BM_EDGE){ - for(v= BMIter_New(&verts, bm, BM_VERTS, bm ); v; v= BMIter_Step(&verts)) + for(v= BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm ); v; v= BMIter_Step(&verts)) BM_Select_Vert(bm, v, 0); - for(e= BMIter_New(&edges, bm, BM_EDGES, bm ); e; e= BMIter_Step(&edges)){ + for(e= BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm ); e; e= BMIter_Step(&edges)){ if(bmesh_test_sysflag(&(e->head), BM_SELECT)) BM_Select_Edge(bm, e, 1); } bmesh_selectmode_flush(bm); } else if(bm->selectmode & BM_FACE){ - for(e = BMIter_New(&edges, bm, BM_EDGES, bm ); e; e= BMIter_Step(&edges)) + for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm ); e; e= BMIter_Step(&edges)) BM_Select_Edge(bm, e, 0); - for(f = BMIter_New(&faces, bm, BM_FACES, bm ); f; f= BMIter_Step(&faces)){ + for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm ); f; f= BMIter_Step(&faces)){ if(bmesh_test_sysflag(&(f->head), BM_SELECT)) BM_Select_Face(bm, f, 1); } @@ -207,17 +207,17 @@ int BM_CountFlag(struct BMesh *bm, int type, int flag) int tot = 0; if (type & BM_VERT) { - for (head = BMIter_New(&iter, bm, BM_VERTS, NULL); head; head=BMIter_Step(&iter)) { + for (head = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); head; head=BMIter_Step(&iter)) { if (head->flag & flag) tot++; } } if (type & BM_EDGE) { - for (head = BMIter_New(&iter, bm, BM_EDGES, NULL); head; head=BMIter_Step(&iter)) { + for (head = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL); head; head=BMIter_Step(&iter)) { if (head->flag & flag) tot++; } } if (type & BM_FACE) { - for (head = BMIter_New(&iter, bm, BM_FACES, NULL); head; head=BMIter_Step(&iter)) { + for (head = BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL); head; head=BMIter_Step(&iter)) { if (head->flag & flag) tot++; } } diff --git a/source/blender/bmesh/intern/bmesh_mesh.c b/source/blender/bmesh/intern/bmesh_mesh.c index 95de605f7ac..6d5459c0cc3 100644 --- a/source/blender/bmesh/intern/bmesh_mesh.c +++ b/source/blender/bmesh/intern/bmesh_mesh.c @@ -132,9 +132,9 @@ void BM_Free_Mesh(BMesh *bm) BMIter faces; BMIter loops; - for(v = BMIter_New(&verts, bm, BM_VERTS, bm ); v; v = BMIter_Step(&verts)) CustomData_bmesh_free_block( &(bm->vdata), &(v->data) ); - for(e = BMIter_New(&edges, bm, BM_EDGES, bm ); e; e = BMIter_Step(&edges)) CustomData_bmesh_free_block( &(bm->edata), &(e->data) ); - for(f = BMIter_New(&faces, bm, BM_FACES, bm ); f; f = BMIter_Step(&faces)){ + for(v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm ); v; v = BMIter_Step(&verts)) CustomData_bmesh_free_block( &(bm->vdata), &(v->data) ); + for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm ); e; e = BMIter_Step(&edges)) CustomData_bmesh_free_block( &(bm->edata), &(e->data) ); + for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm ); f; f = BMIter_Step(&faces)){ CustomData_bmesh_free_block( &(bm->pdata), &(f->data) ); for(l = BMIter_New(&loops, bm, BM_LOOPS_OF_FACE, f ); l; l = BMIter_Step(&loops)) CustomData_bmesh_free_block( &(bm->ldata), &(l->data) ); } @@ -160,6 +160,7 @@ void BM_Free_Mesh(BMesh *bm) /*destroy flag pool*/ BLI_mempool_destroy(bm->flagpool); + BMO_ClearStack(bm); MEM_freeN(bm); } @@ -185,7 +186,7 @@ void BM_Compute_Normals(BMesh *bm) float (*projectverts)[3]; /*first, find out the largest face in mesh*/ - for(f = BMIter_New(&faces, bm, BM_FACES, bm ); f; f = BMIter_Step(&faces)){ + for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm ); f; f = BMIter_Step(&faces)){ if(f->len > maxlength) maxlength = f->len; } @@ -196,21 +197,21 @@ void BM_Compute_Normals(BMesh *bm) projectverts = MEM_callocN(sizeof(float) * maxlength * 3, "BM normal computation array"); /*calculate all face normals*/ - for(f = BMIter_New(&faces, bm, BM_FACES, bm ); f; f = BMIter_Step(&faces)){ + for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm ); f; f = BMIter_Step(&faces)){ if (f->head.flag & BM_NONORMCALC) continue; bmesh_update_face_normal(bm, f, projectverts); } /*Zero out vertex normals*/ - for(v = BMIter_New(&verts, bm, BM_VERTS, bm ); v; v = BMIter_Step(&verts)) v->no[0] = v->no[1] = v->no[2] = 0.0; + for(v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm ); v; v = BMIter_Step(&verts)) v->no[0] = v->no[1] = v->no[2] = 0.0; /*add face normals to vertices*/ - for(f = BMIter_New(&faces, bm, BM_FACES, bm ); f; f = BMIter_Step(&faces)){ + for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm ); f; f = BMIter_Step(&faces)){ for(l = BMIter_New(&loops, bm, BM_LOOPS_OF_FACE, f ); l; l = BMIter_Step(&loops)) VecAddf(l->v->no, l->v->no, f->no); } /*average the vertex normals*/ - for(v = BMIter_New(&verts, bm, BM_VERTS, bm ); v; v= BMIter_Step(&verts)){ + for(v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm ); v; v= BMIter_Step(&verts)){ if (Normalize(v->no)==0.0) { VECCOPY(v->no, v->co); Normalize(v->no); diff --git a/source/blender/bmesh/intern/bmesh_mods.c b/source/blender/bmesh/intern/bmesh_mods.c index 1205e368f89..83a733a8e15 100644 --- a/source/blender/bmesh/intern/bmesh_mods.c +++ b/source/blender/bmesh/intern/bmesh_mods.c @@ -47,7 +47,7 @@ int BM_Dissolve_Vert(BMesh *bm, BMVert *v) { if (!v) return 0; - e = BMIter_New(&iter, bm, BM_EDGES_OF_VERT, v); + e = BMIter_New(&iter, bm, BM_EDGES_OF_MESH_OF_VERT, v); for (; e; e=BMIter_Step(&iter)) { len++; } @@ -171,7 +171,7 @@ void BM_Dissolve_Disk(BMesh *bm, BMVert *v){ done = 1; /*loop the edges looking for an edge to dissolve*/ - for (e=BMIter_New(&iter, bm, BM_EDGES_OF_VERT, v); e; + for (e=BMIter_New(&iter, bm, BM_EDGES_OF_MESH_OF_VERT, v); e; e = BMIter_Step(&iter)) { f = NULL; len = bmesh_cycle_length(&(e->loop->radial)); @@ -247,8 +247,8 @@ BMEdge *BM_Connect_Verts(BMesh *bm, BMVert *v1, BMVert *v2, BMFace **nf) { /*this isn't the best thing in the world. it doesn't handle cases where there's multiple faces yet. that might require a convexity test to figure out which face is "best," and who knows what for non-manifold conditions.*/ - for (face = BMIter_New(&iter, bm, BM_FACES_OF_VERT, v1); face; face=BMIter_Step(&iter)) { - for (v=BMIter_New(&iter2, bm, BM_VERTS_OF_FACE, face); v; v=BMIter_Step(&iter2)) { + for (face = BMIter_New(&iter, bm, BM_FACES_OF_MESH_OF_VERT, v1); face; face=BMIter_Step(&iter)) { + for (v=BMIter_New(&iter2, bm, BM_VERTS_OF_MESH_OF_FACE, face); v; v=BMIter_Step(&iter2)) { if (v == v2) { face = BM_Split_Face(bm, face, v1, v2, &nl, NULL); @@ -347,8 +347,14 @@ BMVert *BM_Split_Edge(BMesh *bm, BMVert *v, BMEdge *e, BMEdge **ne, float percen VECSUB(nv->co,v2->co,v->co); VECADDFAC(nv->co,v->co,nv->co,percent); if (ne) { - if(bmesh_test_sysflag(&(e->head), BM_SELECT)) bmesh_set_sysflag(&((*ne)->head), BM_SELECT); - if(bmesh_test_sysflag(&(e->head), BM_HIDDEN)) bmesh_set_sysflag(&((*ne)->head), BM_HIDDEN); + if(bmesh_test_sysflag(&(e->head), BM_SELECT)) { + bmesh_set_sysflag((BMHeader*)*ne, BM_SELECT); + bmesh_set_sysflag((BMHeader*)nv, BM_SELECT); + } + if(bmesh_test_sysflag(&(e->head), BM_HIDDEN)) { + bmesh_set_sysflag((BMHeader*)*ne, BM_HIDDEN); + bmesh_set_sysflag((BMHeader*)nv, BM_HIDDEN); + } } /*v->nv->v2*/ BM_Data_Facevert_Edgeinterp(bm,v2, v, nv, e, percent); diff --git a/source/blender/bmesh/intern/bmesh_opdefines.c b/source/blender/bmesh/intern/bmesh_opdefines.c index cdd229b2ca0..ed54aeb15d8 100644 --- a/source/blender/bmesh/intern/bmesh_opdefines.c +++ b/source/blender/bmesh/intern/bmesh_opdefines.c @@ -6,9 +6,9 @@ BMOpDefine def_connectverts = { "connectverts", {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, - {BMOP_OPSLOT_ELEMENT_BUF, "edgeout"}}, + {BMOP_OPSLOT_ELEMENT_BUF, "edgeout"}, + {0} /*null-terminating sentinel*/}, connectverts_exec, - BM_CONVERTS_TOTSLOT, 0 }; @@ -16,34 +16,33 @@ BMOpDefine def_extrudefaceregion = { "extrudefaceregion", {{BMOP_OPSLOT_ELEMENT_BUF, "edgefacein"}, {BMOP_OPSLOT_MAPPING, "exclude"}, - {BMOP_OPSLOT_ELEMENT_BUF, "geomout"}}, + {BMOP_OPSLOT_ELEMENT_BUF, "geomout"}, + {0} /*null-terminating sentinel*/}, extrude_edge_context_exec, - BMOP_EXFACE_TOTSLOT, 0 }; BMOpDefine def_makefgonsop = { "makefgon", - {0}, + {{0} /*null-terminating sentinel*/}, bmesh_make_fgons_exec, - BMOP_MAKE_FGONS_TOTSLOT, 0 }; BMOpDefine def_dissolvevertsop = { "dissolveverts", - {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}}, + {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, + {0} /*null-terminating sentinel*/}, dissolveverts_exec, - BMOP_DISVERTS_TOTSLOT, 0 }; BMOpDefine def_dissolvefacesop = { "dissolvefaces", {{BMOP_OPSLOT_ELEMENT_BUF, "faces"}, - {BMOP_OPSLOT_ELEMENT_BUF, "regionnout"}}, + {BMOP_OPSLOT_ELEMENT_BUF, "regionout"}, + {0} /*null-terminating sentinel*/}, dissolvefaces_exec, - BMOP_DISFACES_TOTSLOT, 0 }; @@ -53,9 +52,9 @@ BMOpDefine def_triangop = { {{BMOP_OPSLOT_ELEMENT_BUF, "faces"}, {BMOP_OPSLOT_ELEMENT_BUF, "edgeout"}, {BMOP_OPSLOT_ELEMENT_BUF, "faceout"}, - {BMOP_OPSLOT_MAPPING, "facemap"}}, + {BMOP_OPSLOT_MAPPING, "facemap"}, + {0} /*null-terminating sentinel*/}, triangulate_exec, - BMOP_TRIANG_TOTSLOT, 0 }; @@ -67,35 +66,37 @@ BMOpDefine def_subdop = { {BMOP_OPSLOT_FLT, "radius"}, {BMOP_OPSLOT_MAPPING, "custompatterns"}, {BMOP_OPSLOT_MAPPING, "edgepercents"}, + + /*these next two can have multiple types of elements in them.*/ {BMOP_OPSLOT_ELEMENT_BUF, "outinner"}, {BMOP_OPSLOT_ELEMENT_BUF, "outsplit"}, + {0} /*null-terminating sentinel*/, }, esubdivide_exec, - BMOP_ESUBDIVIDE_TOTSLOT, 0 }; BMOpDefine def_edit2bmesh = { "editmesh_to_bmesh", - {{BMOP_OPSLOT_PNT, "em"}, {BMOP_OPSLOT_MAPPING, "map"}}, + {{BMOP_OPSLOT_PNT, "em"}, {BMOP_OPSLOT_MAPPING, "map"}, + {0} /*null-terminating sentinel*/}, edit2bmesh_exec, - BMOP_FROM_EDITMESH_TOTSLOT, 0 }; BMOpDefine def_bmesh2edit = { "bmesh_to_editmesh", - {{BMOP_OPSLOT_PNT, "emout"}}, + {{BMOP_OPSLOT_PNT, "emout"}, + {0} /*null-terminating sentinel*/}, bmesh2edit_exec, - BMOP_TO_EDITMESH_TOTSLOT, 0 }; BMOpDefine def_delop = { "del", - {{BMOP_OPSLOT_ELEMENT_BUF, "geom"}, {BMOP_OPSLOT_INT, "context"}}, + {{BMOP_OPSLOT_ELEMENT_BUF, "geom"}, {BMOP_OPSLOT_INT, "context"}, + {0} /*null-terminating sentinel*/}, delop_exec, - BMOP_DEL_TOTSLOT, 0 }; @@ -105,9 +106,9 @@ BMOpDefine def_dupeop = { {BMOP_OPSLOT_ELEMENT_BUF, "origout"}, {BMOP_OPSLOT_ELEMENT_BUF, "newout"}, {BMOP_OPSLOT_MAPPING, "boundarymap"}, - {BMOP_OPSLOT_MAPPING, "isovertmap"}}, + {BMOP_OPSLOT_MAPPING, "isovertmap"}, + {0} /*null-terminating sentinel*/}, dupeop_exec, - BMOP_DUPE_TOTSLOT, 0 }; @@ -116,9 +117,9 @@ BMOpDefine def_splitop = { {{BMOP_OPSLOT_ELEMENT_BUF, "geom"}, {BMOP_OPSLOT_ELEMENT_BUF, "geomout"}, {BMOP_OPSLOT_MAPPING, "boundarymap"}, - {BMOP_OPSLOT_MAPPING, "isovertmap"}}, + {BMOP_OPSLOT_MAPPING, "isovertmap"}, + {0} /*null-terminating sentinel*/}, splitop_exec, - BMOP_SPLIT_TOTSLOT, 0 }; diff --git a/source/blender/bmesh/intern/bmesh_operators.c b/source/blender/bmesh/intern/bmesh_operators.c index 1b51ff1138f..61e73bb2e8c 100644 --- a/source/blender/bmesh/intern/bmesh_operators.c +++ b/source/blender/bmesh/intern/bmesh_operators.c @@ -16,6 +16,8 @@ static void alloc_flag_layer(BMesh *bm); static void free_flag_layer(BMesh *bm); static void clear_flag_layer(BMesh *bm); +static int bmesh_name_to_slotcode(BMOpDefine *def, char *name); +static int bmesh_opname_to_opcode(char *opname); typedef void (*opexec)(struct BMesh *bm, struct BMOperator *op); @@ -29,6 +31,7 @@ typedef struct element_mapping { /*operator slot type information - size of one element of the type given.*/ const int BMOP_OPSLOT_TYPEINFO[] = { + 0, sizeof(int), sizeof(float), sizeof(void*), @@ -84,15 +87,15 @@ void BMO_pop(BMesh *bm) * */ -void BMO_Init_Op(BMOperator *op, int opcode) +void BMO_Init_Op(BMOperator *op, char *opname) { - int i; + int i, opcode = bmesh_opname_to_opcode(opname); memset(op, 0, sizeof(BMOperator)); op->type = opcode; /*initialize the operator slot types*/ - for(i = 0; i < opdefines[opcode]->totslot; i++) { + for(i = 0; opdefines[opcode]->slottypes[i].type; i++) { op->slots[i].slottype = opdefines[opcode]->slottypes[i].type; op->slots[i].index = i; } @@ -144,7 +147,7 @@ void BMO_Finish_Op(BMesh *bm, BMOperator *op) BMOpSlot *slot; int i; - for (i=0; itype]->totslot; i++) { + for (i=0; opdefines[op->type]->slottypes[i].type; i++) { slot = &op->slots[i]; if (slot->slottype == BMOP_OPSLOT_MAPPING) { if (slot->data.ghash) @@ -163,8 +166,10 @@ void BMO_Finish_Op(BMesh *bm, BMOperator *op) * */ -BMOpSlot *BMO_GetSlot(BMOperator *op, int slotcode) +BMOpSlot *BMO_GetSlot(BMOperator *op, char *slotname) { + int slotcode = bmesh_name_to_slotcode(opdefines[op->type], slotname); + return &(op->slots[slotcode]); } @@ -175,10 +180,10 @@ BMOpSlot *BMO_GetSlot(BMOperator *op, int slotcode) * */ -void BMO_CopySlot(BMOperator *source_op, BMOperator *dest_op, int src, int dst) +void BMO_CopySlot(BMOperator *source_op, BMOperator *dest_op, char *src, char *dst) { - BMOpSlot *source_slot = &source_op->slots[src]; - BMOpSlot *dest_slot = &dest_op->slots[dst]; + BMOpSlot *source_slot = BMO_GetSlot(source_op, src); + BMOpSlot *dest_slot = BMO_GetSlot(dest_op, dst); if(source_slot == dest_slot) return; @@ -236,35 +241,79 @@ void BMO_CopySlot(BMOperator *source_op, BMOperator *dest_op, int src, int dst) */ -void BMO_Set_Float(BMOperator *op, int slotcode, float f) +void BMO_Set_Float(BMOperator *op, char *slotname, float f) { - if( !(op->slots[slotcode].slottype == BMOP_OPSLOT_FLT) ) + BMOpSlot *slot = BMO_GetSlot(op, slotname); + if( !(slot->slottype == BMOP_OPSLOT_FLT) ) return; - op->slots[slotcode].data.f = f; + + slot->data.f = f; } -void BMO_Set_Int(BMOperator *op, int slotcode, int i) +void BMO_Set_Int(BMOperator *op, char *slotname, int i) { - if( !(op->slots[slotcode].slottype == BMOP_OPSLOT_INT) ) + BMOpSlot *slot = BMO_GetSlot(op, slotname); + if( !(slot->slottype == BMOP_OPSLOT_INT) ) return; - op->slots[slotcode].data.i = i; + slot->data.i = i; } -void BMO_Set_Pnt(BMOperator *op, int slotcode, void *p) +void BMO_Set_Pnt(BMOperator *op, char *slotname, void *p) { - if( !(op->slots[slotcode].slottype == BMOP_OPSLOT_PNT) ) + BMOpSlot *slot = BMO_GetSlot(op, slotname); + if( !(slot->slottype == BMOP_OPSLOT_PNT) ) return; - op->slots[slotcode].data.p = p; + + slot->data.p = p; } -void BMO_Set_Vec(BMOperator *op, int slotcode, float *vec) +void BMO_Set_Vec(BMOperator *op, char *slotname, float *vec) { - if( !(op->slots[slotcode].slottype == BMOP_OPSLOT_VEC) ) + BMOpSlot *slot = BMO_GetSlot(op, slotname); + if( !(slot->slottype == BMOP_OPSLOT_VEC) ) return; - VECCOPY(op->slots[slotcode].data.vec, vec); + VECCOPY(slot->data.vec, vec); +} + + +float BMO_Get_Float(BMOperator *op, char *slotname) +{ + BMOpSlot *slot = BMO_GetSlot(op, slotname); + if( !(slot->slottype == BMOP_OPSLOT_FLT) ) + return 0.0f; + + return slot->data.f; +} + +int BMO_Get_Int(BMOperator *op, char *slotname) +{ + BMOpSlot *slot = BMO_GetSlot(op, slotname); + if( !(slot->slottype == BMOP_OPSLOT_INT) ) + return 0; + + return slot->data.i; +} + + +void *BMO_Get_Pnt(BMOperator *op, char *slotname) +{ + BMOpSlot *slot = BMO_GetSlot(op, slotname); + if( !(slot->slottype == BMOP_OPSLOT_PNT) ) + return NULL; + + return slot->data.p; +} + +void BMO_Get_Vec(BMOperator *op, char *slotname, float *vec_out) +{ + BMOpSlot *slot = BMO_GetSlot(op, slotname); + if( !(slot->slottype == BMOP_OPSLOT_VEC) ) + return; + + VECCOPY(vec_out, slot->data.vec); } /* @@ -323,19 +372,19 @@ int BMO_CountFlag(BMesh *bm, int flag, int type) int count = 0; if(type & BM_VERT){ - for(e = BMIter_New(&elements, bm, BM_VERTS, bm); e; e = BMIter_Step(&elements)){ + for(e = BMIter_New(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BMIter_Step(&elements)){ if(BMO_TestFlag(bm, e, flag)) count++; } } if(type & BM_EDGE){ - for(e = BMIter_New(&elements, bm, BM_EDGES, bm); e; e = BMIter_Step(&elements)){ + for(e = BMIter_New(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&elements)){ if(BMO_TestFlag(bm, e, flag)) count++; } } if(type & BM_FACE){ - for(e = BMIter_New(&elements, bm, BM_FACES, bm); e; e = BMIter_Step(&elements)){ + for(e = BMIter_New(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BMIter_Step(&elements)){ if(BMO_TestFlag(bm, e, flag)) count++; } @@ -344,9 +393,9 @@ int BMO_CountFlag(BMesh *bm, int flag, int type) return count; } -int BMO_CountSlotBuf(struct BMesh *bm, struct BMOperator *op, int slotcode) +int BMO_CountSlotBuf(struct BMesh *bm, struct BMOperator *op, char *slotname) { - BMOpSlot *slot = &op->slots[slotcode]; + BMOpSlot *slot = BMO_GetSlot(op, slotname); /*check if its actually a buffer*/ if( !(slot->slottype > BMOP_OPSLOT_VEC) ) @@ -388,10 +437,10 @@ void *BMO_Grow_Array(BMesh *bm, BMOperator *op, int slotcode, int totadd) { } #endif -void BMO_Insert_Mapping(BMesh *bm, BMOperator *op, int slotcode, +void BMO_Insert_Mapping(BMesh *bm, BMOperator *op, char *slotname, void *element, void *data, int len) { element_mapping *mapping; - BMOpSlot *slot = &op->slots[slotcode]; + BMOpSlot *slot = BMO_GetSlot(op, slotname); /*sanity check*/ if (slot->slottype != BMOP_OPSLOT_MAPPING) return; @@ -411,10 +460,10 @@ void BMO_Insert_Mapping(BMesh *bm, BMOperator *op, int slotcode, } void BMO_Mapping_To_Flag(struct BMesh *bm, struct BMOperator *op, - int slotcode, int flag) + char *slotname, int flag) { GHashIterator it; - BMOpSlot *slot = &op->slots[slotcode]; + BMOpSlot *slot = BMO_GetSlot(op, slotname); BMHeader *ele; /*sanity check*/ @@ -427,21 +476,21 @@ void BMO_Mapping_To_Flag(struct BMesh *bm, struct BMOperator *op, } } -void BMO_Insert_MapFloat(BMesh *bm, BMOperator *op, int slotcode, +void BMO_Insert_MapFloat(BMesh *bm, BMOperator *op, char *slotname, void *element, float val) { - BMO_Insert_Mapping(bm, op, slotcode, element, &val, sizeof(float)); + BMO_Insert_Mapping(bm, op, slotname, element, &val, sizeof(float)); } -void BMO_Insert_MapPointer(BMesh *bm, BMOperator *op, int slotcode, +void BMO_Insert_MapPointer(BMesh *bm, BMOperator *op, char *slotname, void *element, void *val) { - BMO_Insert_Mapping(bm, op, slotcode, element, &val, sizeof(void*)); + BMO_Insert_Mapping(bm, op, slotname, element, &val, sizeof(void*)); } -int BMO_InMap(BMesh *bm, BMOperator *op, int slotcode, void *element) +int BMO_InMap(BMesh *bm, BMOperator *op, char *slotname, void *element) { - BMOpSlot *slot = &op->slots[slotcode]; + BMOpSlot *slot = BMO_GetSlot(op, slotname); /*sanity check*/ if (slot->slottype != BMOP_OPSLOT_MAPPING) return 0; @@ -450,11 +499,11 @@ int BMO_InMap(BMesh *bm, BMOperator *op, int slotcode, void *element) return BLI_ghash_haskey(slot->data.ghash, element); } -void *BMO_Get_MapData(BMesh *bm, BMOperator *op, int slotcode, +void *BMO_Get_MapData(BMesh *bm, BMOperator *op, char *slotname, void *element) { element_mapping *mapping; - BMOpSlot *slot = &op->slots[slotcode]; + BMOpSlot *slot = BMO_GetSlot(op, slotname); /*sanity check*/ if (slot->slottype != BMOP_OPSLOT_MAPPING) return NULL; @@ -467,25 +516,26 @@ void *BMO_Get_MapData(BMesh *bm, BMOperator *op, int slotcode, return mapping + 1; } -float BMO_Get_MapFloat(BMesh *bm, BMOperator *op, int slotcode, +float BMO_Get_MapFloat(BMesh *bm, BMOperator *op, char *slotname, void *element) { - float *val = BMO_Get_MapData(bm, op, slotcode, element); + float *val = BMO_Get_MapData(bm, op, slotname, element); if (val) return *val; return 0.0f; } -void *BMO_Get_MapPointer(BMesh *bm, BMOperator *op, int slotcode, +void *BMO_Get_MapPointer(BMesh *bm, BMOperator *op, char *slotname, void *element) { - void **val = BMO_Get_MapData(bm, op, slotcode, element); + void **val = BMO_Get_MapData(bm, op, slotname, element); if (val) return *val; return NULL; } -static void *alloc_slot_buffer(BMOperator *op, int slotcode, int len){ +static void *alloc_slot_buffer(BMOperator *op, char *slotname, int len){ + int slotcode = bmesh_name_to_slotcode(opdefines[op->type], slotname); /*check if its actually a buffer*/ if( !(op->slots[slotcode].slottype > BMOP_OPSLOT_VEC) ) @@ -506,20 +556,20 @@ static void *alloc_slot_buffer(BMOperator *op, int slotcode, int len){ * */ -void BMO_HeaderFlag_To_Slot(BMesh *bm, BMOperator *op, int slotcode, int flag, int type) +void BMO_HeaderFlag_To_Slot(BMesh *bm, BMOperator *op, char *slotname, int flag, int type) { BMIter elements; BMHeader *e; - BMOpSlot *output = BMO_GetSlot(op, slotcode); + BMOpSlot *output = BMO_GetSlot(op, slotname); int totelement=0, i=0; totelement = BM_CountFlag(bm, type, BM_SELECT); if(totelement){ - alloc_slot_buffer(op, slotcode, totelement); + alloc_slot_buffer(op, slotname, totelement); if (type & BM_VERT) { - for (e = BMIter_New(&elements, bm, BM_VERTS, bm); e; e = BMIter_Step(&elements)) { + for (e = BMIter_New(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BMIter_Step(&elements)) { if(e->flag & flag) { ((BMHeader**)output->data.p)[i] = e; i++; @@ -528,7 +578,7 @@ void BMO_HeaderFlag_To_Slot(BMesh *bm, BMOperator *op, int slotcode, int flag, i } if (type & BM_EDGE) { - for (e = BMIter_New(&elements, bm, BM_EDGES, bm); e; e = BMIter_Step(&elements)) { + for (e = BMIter_New(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&elements)) { if(e->flag & flag){ ((BMHeader**)output->data.p)[i] = e; i++; @@ -537,7 +587,7 @@ void BMO_HeaderFlag_To_Slot(BMesh *bm, BMOperator *op, int slotcode, int flag, i } if (type & BM_FACE) { - for (e = BMIter_New(&elements, bm, BM_FACES, bm); e; e = BMIter_Step(&elements)) { + for (e = BMIter_New(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BMIter_Step(&elements)) { if(e->flag & flag){ ((BMHeader**)output->data.p)[i] = e; i++; @@ -555,18 +605,18 @@ void BMO_HeaderFlag_To_Slot(BMesh *bm, BMOperator *op, int slotcode, int flag, i * into an output slot for an operator. * */ -void BMO_Flag_To_Slot(BMesh *bm, BMOperator *op, int slotcode, int flag, int type) +void BMO_Flag_To_Slot(BMesh *bm, BMOperator *op, char *slotname, int flag, int type) { BMIter elements; BMHeader *e; - BMOpSlot *output = BMO_GetSlot(op, slotcode); + BMOpSlot *output = BMO_GetSlot(op, slotname); int totelement = BMO_CountFlag(bm, flag, type), i=0; if(totelement){ - alloc_slot_buffer(op, slotcode, totelement); + alloc_slot_buffer(op, slotname, totelement); if (type & BM_VERT) { - for (e = BMIter_New(&elements, bm, BM_VERTS, bm); e; e = BMIter_Step(&elements)) { + for (e = BMIter_New(&elements, bm, BM_VERTS_OF_MESH, bm); e; e = BMIter_Step(&elements)) { if(BMO_TestFlag(bm, e, flag)){ ((BMHeader**)output->data.p)[i] = e; i++; @@ -575,7 +625,7 @@ void BMO_Flag_To_Slot(BMesh *bm, BMOperator *op, int slotcode, int flag, int typ } if (type & BM_EDGE) { - for (e = BMIter_New(&elements, bm, BM_EDGES, bm); e; e = BMIter_Step(&elements)) { + for (e = BMIter_New(&elements, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&elements)) { if(BMO_TestFlag(bm, e, flag)){ ((BMHeader**)output->data.p)[i] = e; i++; @@ -584,7 +634,7 @@ void BMO_Flag_To_Slot(BMesh *bm, BMOperator *op, int slotcode, int flag, int typ } if (type & BM_FACE) { - for (e = BMIter_New(&elements, bm, BM_FACES, bm); e; e = BMIter_Step(&elements)) { + for (e = BMIter_New(&elements, bm, BM_FACES_OF_MESH, bm); e; e = BMIter_Step(&elements)) { if(BMO_TestFlag(bm, e, flag)){ ((BMHeader**)output->data.p)[i] = e; i++; @@ -602,9 +652,9 @@ void BMO_Flag_To_Slot(BMesh *bm, BMOperator *op, int slotcode, int flag, int typ * */ -void BMO_Flag_Buffer(BMesh *bm, BMOperator *op, int slotcode, int flag) +void BMO_Flag_Buffer(BMesh *bm, BMOperator *op, char *slotname, int flag) { - BMOpSlot *slot = BMO_GetSlot(op, slotcode); + BMOpSlot *slot = BMO_GetSlot(op, slotname); BMHeader **data = slot->data.p; int i; @@ -620,9 +670,9 @@ void BMO_Flag_Buffer(BMesh *bm, BMOperator *op, int slotcode, int flag) * */ -void BMO_Unflag_Buffer(BMesh *bm, BMOperator *op, int slotcode, int flag) +void BMO_Unflag_Buffer(BMesh *bm, BMOperator *op, char *slotname, int flag) { - BMOpSlot *slot = BMO_GetSlot(op, slotcode); + BMOpSlot *slot = BMO_GetSlot(op, slotname); BMHeader **data = slot->data.p; int i; @@ -663,17 +713,17 @@ static void alloc_flag_layer(BMesh *bm) bm->flagpool = BLI_mempool_create(sizeof(BMFlagLayer)*(bm->totflags+1), 512, 512 ); /*now go through and memcpy all the flags. Loops don't get a flag layer at this time...*/ - for(v = BMIter_New(&verts, bm, BM_VERTS, bm); v; v = BMIter_Step(&verts)){ + for(v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts)){ oldflags = v->head.flags; v->head.flags = BLI_mempool_calloc(bm->flagpool); memcpy(v->head.flags, oldflags, sizeof(BMFlagLayer)*bm->totflags); /*dont know if this memcpy usage is correct*/ } - for(e = BMIter_New(&edges, bm, BM_EDGES, bm); e; e = BMIter_Step(&edges)){ + for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)){ oldflags = e->head.flags; e->head.flags = BLI_mempool_calloc(bm->flagpool); memcpy(e->head.flags, oldflags, sizeof(BMFlagLayer)*bm->totflags); } - for(f = BMIter_New(&faces, bm, BM_FACES, bm); f; f = BMIter_Step(&faces)){ + for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)){ oldflags = f->head.flags; f->head.flags = BLI_mempool_calloc(bm->flagpool); memcpy(f->head.flags, oldflags, sizeof(BMFlagLayer)*bm->totflags); @@ -700,17 +750,17 @@ static void free_flag_layer(BMesh *bm) bm->flagpool = BLI_mempool_create(sizeof(BMFlagLayer)*bm->totflags, 512, 512); /*now go through and memcpy all the flags*/ - for(v = BMIter_New(&verts, bm, BM_VERTS, bm); v; v = BMIter_Step(&verts)){ + for(v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts)){ oldflags = v->head.flags; v->head.flags = BLI_mempool_calloc(bm->flagpool); memcpy(v->head.flags, oldflags, sizeof(BMFlagLayer)*bm->totflags); /*correct?*/ } - for(e = BMIter_New(&edges, bm, BM_EDGES, bm); e; e = BMIter_Step(&edges)){ + for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)){ oldflags = e->head.flags; e->head.flags = BLI_mempool_calloc(bm->flagpool); memcpy(e->head.flags, oldflags, sizeof(BMFlagLayer)*bm->totflags); } - for(f = BMIter_New(&faces, bm, BM_FACES, bm); f; f = BMIter_Step(&faces)){ + for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)){ oldflags = f->head.flags; f->head.flags = BLI_mempool_calloc(bm->flagpool); memcpy(f->head.flags, oldflags, sizeof(BMFlagLayer)*bm->totflags); @@ -730,21 +780,21 @@ static void clear_flag_layer(BMesh *bm) BMIter faces; /*now go through and memcpy all the flags*/ - for(v = BMIter_New(&verts, bm, BM_VERTS, bm); v; v = BMIter_Step(&verts)){ + for(v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts)){ memset(v->head.flags+bm->totflags-1, 0, sizeof(BMFlagLayer)); } - for(e = BMIter_New(&edges, bm, BM_EDGES, bm); e; e = BMIter_Step(&edges)){ + for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)){ memset(e->head.flags+bm->totflags-1, 0, sizeof(BMFlagLayer)); } - for(f = BMIter_New(&faces, bm, BM_FACES, bm); f; f = BMIter_Step(&faces)){ + for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)){ memset(f->head.flags+bm->totflags-1, 0, sizeof(BMFlagLayer)); } } void *BMO_IterNew(BMOIter *iter, BMesh *bm, BMOperator *op, - int slotcode) + char *slotname) { - BMOpSlot *slot = &op->slots[slotcode]; + BMOpSlot *slot = BMO_GetSlot(op, slotname); iter->slot = slot; iter->cur = 0; @@ -891,17 +941,34 @@ static int bmesh_name_to_slotcode(BMOpDefine *def, char *name) { int i; - for (i=0; itotslot; i++) { + for (i=0; def->slottypes[i].type; i++) { if (!strcmp(name, def->slottypes[i].name)) return i; } + + printf("yeek! could not find bmesh slot for name %s!\n", name); + return 0; +} - return -1; +static int bmesh_opname_to_opcode(char *opname) { + int i; + + for (i=0; iname)) break; + } + + if (i == bmesh_total_ops) { + printf("yeek!! invalid op name %s!\n", opname); + return 0; + } + + return i; } int BMO_VInitOpf(BMesh *bm, BMOperator *op, char *fmt, va_list vlist) { int i, n=strlen(fmt), stop, slotcode = -1, ret, type, state, c; char *opname, *ofmt; + char slotname[64] = {0}; BMOpDefine *def; /*we muck around in here, so dup it*/ @@ -921,7 +988,7 @@ int BMO_VInitOpf(BMesh *bm, BMOperator *op, char *fmt, va_list vlist) if (i == bmesh_total_ops) return 0; - BMO_Init_Op(op, i); + BMO_Init_Op(op, opname); def = opdefines[i]; i = 0; @@ -945,9 +1012,11 @@ int BMO_VInitOpf(BMesh *bm, BMOperator *op, char *fmt, va_list vlist) if (!fmt[i]) goto error; fmt[i] = 0; - slotcode = bmesh_name_to_slotcode(def, fmt); - if (slotcode < 0) goto error; + if (bmesh_name_to_slotcode(def, fmt) < 0) goto error; + + strcpy(slotname, fmt); + state = 0; fmt += i; } else { @@ -959,7 +1028,7 @@ int BMO_VInitOpf(BMesh *bm, BMOperator *op, char *fmt, va_list vlist) break; case 'i': case 'd': - BMO_Set_Int(op, slotcode, va_arg(vlist, int)); + BMO_Set_Int(op, slotname, va_arg(vlist, int)); state = 1; break; case 'f': @@ -969,7 +1038,7 @@ int BMO_VInitOpf(BMesh *bm, BMOperator *op, char *fmt, va_list vlist) if (nextc(fmt) == ' ' || nextc(fmt) == '\t' || nextc(fmt)==0) { - BMO_Set_Float(op,slotcode,va_arg(vlist,double)); + BMO_Set_Float(op,slotname,va_arg(vlist,double)); } else { ret = 0; stop = 0; @@ -988,9 +1057,9 @@ int BMO_VInitOpf(BMesh *bm, BMOperator *op, char *fmt, va_list vlist) if (type == 'h') BMO_HeaderFlag_To_Slot(bm, op, - slotcode, va_arg(vlist, int), ret); + slotname, va_arg(vlist, int), ret); else - BMO_Flag_To_Slot(bm, op, slotcode, + BMO_Flag_To_Slot(bm, op, slotname, va_arg(vlist, int), ret); } diff --git a/source/blender/bmesh/intern/bmesh_polygon.c b/source/blender/bmesh/intern/bmesh_polygon.c index 5c218a70f5e..7d9d77c39be 100644 --- a/source/blender/bmesh/intern/bmesh_polygon.c +++ b/source/blender/bmesh/intern/bmesh_polygon.c @@ -338,7 +338,7 @@ void BM_Edge_UpdateNormals(BMesh *bm, BMEdge *e) BMIter iter; BMFace *f; - f = BMIter_New(&iter, bm, BM_FACES_OF_EDGE, e); + f = BMIter_New(&iter, bm, BM_FACES_OF_MESH_OF_EDGE, e); for (; f; f=BMIter_Step(&iter)) { BM_Face_UpdateNormal(bm, f); } @@ -355,7 +355,7 @@ void BM_Vert_UpdateNormal(BMesh *bm, BMVert *v) v->no[0] = v->no[1] = v->no[2] = 0.0f; - f = BMIter_New(&iter, bm, BM_FACES_OF_VERT, v); + f = BMIter_New(&iter, bm, BM_FACES_OF_MESH_OF_VERT, v); for (; f; f=BMIter_Step(&iter), len++) { VecAddf(v->no, f->no, v->no); } @@ -522,11 +522,6 @@ int goodline(float (*projectverts)[3], BMFace *f, int v1i, * */ -typedef struct quadtree { - int *dsdf; - int *dsfds; -} quadtree; - static BMLoop *find_ear(BMesh *bm, BMFace *f, float (*verts)[3], int nvert) { diff --git a/source/blender/bmesh/intern/bmesh_queries.c b/source/blender/bmesh/intern/bmesh_queries.c index c5a9916ae24..fa8d4482deb 100644 --- a/source/blender/bmesh/intern/bmesh_queries.c +++ b/source/blender/bmesh/intern/bmesh_queries.c @@ -98,7 +98,7 @@ int BM_Vert_In_Face(BMFace *f, BMVert *v) * that appear in a given face * */ -int BM_Verts_In_Face(BMesh *bm, BMFace *f, BMVert **varr, int len) +int BM_VERTS_OF_MESH_In_Face(BMesh *bm, BMFace *f, BMVert **varr, int len) { BMLoop *curloop = NULL; int i, count = 0; @@ -146,7 +146,7 @@ int BM_Edge_In_Face(BMFace *f, BMEdge *e) * */ -int BM_Verts_In_Edge(BMVert *v1, BMVert *v2, BMEdge *e) +int BM_VERTS_OF_MESH_In_Edge(BMVert *v1, BMVert *v2, BMEdge *e) { return bmesh_verts_in_edge(v1,v2,e); } @@ -498,9 +498,9 @@ int BM_Exist_Face_Overlaps(BMesh *bm, BMVert **varr, int len, BMFace **overlapfa if (overlapface) *overlapface = NULL; for(i=0; i < len; i++){ - f = BMIter_New(&vertfaces, bm, BM_FACES_OF_VERT, varr[i] ); + f = BMIter_New(&vertfaces, bm, BM_FACES_OF_MESH_OF_VERT, varr[i] ); while(f){ - amount = BM_Verts_In_Face(bm, f, varr, len); + amount = BM_VERTS_OF_MESH_In_Face(bm, f, varr, len); if(amount >= len){ if (overlapface) *overlapface = f; return 1; @@ -534,9 +534,9 @@ int BM_Face_Exists(BMesh *bm, BMVert **varr, int len, BMFace **existface) if (existface) *existface = NULL; for(i=0; i < len; i++){ - f = BMIter_New(&vertfaces, bm, BM_FACES_OF_VERT, varr[i] ); + f = BMIter_New(&vertfaces, bm, BM_FACES_OF_MESH_OF_VERT, varr[i] ); while(f){ - amount = BM_Verts_In_Face(bm, f, varr, len); + amount = BM_VERTS_OF_MESH_In_Face(bm, f, varr, len); if(amount == len && amount == f->len){ if (existface) *existface = f; return 1; diff --git a/source/blender/bmesh/intern/bmesh_to_editmesh.c b/source/blender/bmesh/intern/bmesh_to_editmesh.c index b2dc694b898..f22769f65eb 100644 --- a/source/blender/bmesh/intern/bmesh_to_editmesh.c +++ b/source/blender/bmesh/intern/bmesh_to_editmesh.c @@ -216,15 +216,15 @@ EditMesh *bmesh_to_editmesh_intern(BMesh *bm) evlist= MEM_mallocN(totvert*sizeof(EditVert *),"evlist"); /* make vertices */ - for(i=0, v = BMIter_New(&verts, bm, BM_VERTS, bm); v; v = BMIter_Step(&verts), i++) + for(i=0, v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts), i++) eve = bmeshvert_to_editvert(bm, em, v, i, evlist); /* make edges */ - for(e = BMIter_New(&edges, bm, BM_EDGES, bm); e; e = BMIter_Step(&edges)) + for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) bmeshedge_to_editedge(bm, em, e, evlist); /* make faces */ - for(f = BMIter_New(&faces, bm, BM_FACES, bm); f; f = BMIter_Step(&faces)) + for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)) bmeshface_to_editface(bm, em, f, evlist, numCol, numTex); MEM_freeN(evlist); @@ -240,7 +240,7 @@ EditMesh *bmesh_to_editmesh_intern(BMesh *bm) void bmesh2edit_exec(BMesh *bmesh, BMOperator *op) { - BMO_Set_Pnt(op, BMOP_TO_EDITMESH_EMOUT, bmesh_to_editmesh_intern(bmesh)); + BMO_Set_Pnt(op, "emout", bmesh_to_editmesh_intern(bmesh)); } #define FACE_NGON 1 @@ -254,22 +254,22 @@ void bmesh_make_fgons_exec(BMesh *bmesh, BMOperator *op) BMOpSlot *eout; int i; - BMO_Init_Op(&triop, BMOP_TRIANGULATE); + BMO_Init_Op(&triop, "triangulate"); - for (face = BMIter_New(&iter, bmesh, BM_FACES, NULL); face; face=BMIter_Step(&iter)) { + for (face = BMIter_New(&iter, bmesh, BM_FACES_OF_MESH, NULL); face; face=BMIter_Step(&iter)) { if (face->len > 4) { BMO_SetFlag(bmesh, face, FACE_NGON); } } - BMO_Flag_To_Slot(bmesh, &triop, BMOP_TRIANG_FACEIN, FACE_NGON, BM_FACE); + BMO_Flag_To_Slot(bmesh, &triop, "faces", FACE_NGON, BM_FACE); BMO_Exec_Op(bmesh, &triop); - eout = BMO_GetSlot(&triop, BMOP_TRIANG_NEW_EDGES); + eout = BMO_GetSlot(&triop, "edgeout"); for (i=0; ilen; i++) { edge = ((BMEdge**)eout->data.buf)[i]; edge->head.flag |= BM_FGON; - face = BMIter_New(&iter, bmesh, BM_FACES_OF_EDGE, edge); + face = BMIter_New(&iter, bmesh, BM_FACES_OF_MESH_OF_EDGE, edge); for (; face; face=BMIter_Step(&iter)) { face->head.flag |= BM_NONORMCALC; @@ -285,13 +285,13 @@ EditMesh *bmesh_to_editmesh(BMesh *bmesh) EditMesh *em; /*first fgon-afy the mesh*/ - BMO_Init_Op(&makefgon, BMOP_MAKE_FGONS); + BMO_Init_Op(&makefgon, "makefgon"); BMO_Exec_Op(bmesh, &makefgon); BMO_Finish_Op(bmesh, &makefgon); - BMO_Init_Op(&conv, BMOP_TO_EDITMESH); + BMO_Init_Op(&conv, "bmesh_to_editmesh"); BMO_Exec_Op(bmesh, &conv); - em = conv.slots[BMOP_TO_EDITMESH_EMOUT].data.p; + em = BMO_Get_Pnt(&conv, "emout"); BMO_Finish_Op(bmesh, &conv); return em; diff --git a/source/blender/bmesh/intern/bmesh_walkers.c b/source/blender/bmesh/intern/bmesh_walkers.c index bbca03273ed..ff9a2b18637 100644 --- a/source/blender/bmesh/intern/bmesh_walkers.c +++ b/source/blender/bmesh/intern/bmesh_walkers.c @@ -465,7 +465,7 @@ static void *islandWalker_step(BMWalker *walker) l = BMIter_New(&liter, walker->bm, BM_LOOPS_OF_FACE, iwalk->cur); for (; l; l=BMIter_Step(&liter)) { - f = BMIter_New(&iter, walker->bm, BM_FACES_OF_EDGE, l->e); + f = BMIter_New(&iter, walker->bm, BM_FACES_OF_MESH_OF_EDGE, l->e); for (; f; f=BMIter_Step(&iter)) { if (!BMO_TestFlag(walker->bm, f, walker->restrictflag)) continue; diff --git a/source/blender/bmesh/intern/editmesh_to_bmesh.c b/source/blender/bmesh/intern/editmesh_to_bmesh.c index 987ffd6efaf..ad7bbb7e21e 100644 --- a/source/blender/bmesh/intern/editmesh_to_bmesh.c +++ b/source/blender/bmesh/intern/editmesh_to_bmesh.c @@ -99,7 +99,7 @@ static BMVert *editvert_to_BMVert(BMesh *bm, BMOperator *op, EditMesh *em, EditV if(eve->f & SELECT) BM_Select_Vert(bm, v, 1); v->bweight = eve->bweight; - BMO_Insert_MapPointer(bm, op, BMOP_FROM_EDITMESH_MAP, eve, v); + BMO_Insert_MapPointer(bm, op, "map", eve, v); /*Copy Custom Data*/ CustomData_bmesh_copy_data(&em->vdata, &bm->vdata, eve->data, &v->data); @@ -128,7 +128,7 @@ static void editedge_to_BMEdge_internal(BMesh *bm, BMOperator *op, EditMesh *em, CustomData_bmesh_copy_data(&em->edata, &bm->edata, eed->data, &e->data); - BMO_Insert_MapPointer(bm, op, BMOP_FROM_EDITMESH_MAP, eed, e); + BMO_Insert_MapPointer(bm, op, "map", eed, e); } static BMEdge *editedge_to_BMEdge(BMesh *bm, BMOperator *op, EditMesh *em, EditEdge *eed) @@ -193,7 +193,7 @@ static BMFace *editface_to_BMFace(BMesh *bm, BMOperator *op, EditMesh *em, EditF VECCOPY(f->no, efa->n); - BMO_Insert_MapPointer(bm, op, BMOP_FROM_EDITMESH_MAP, efa, f); + BMO_Insert_MapPointer(bm, op, "map", efa, f); f->head.flag = 0; f->mat_nr = efa->mat_nr; @@ -422,7 +422,7 @@ BMesh *editmesh_to_bmesh_intern(EditMesh *em, BMesh *bm, BMOperator *op) { BM_fgonconvert(bm, op, em, numCol, numTex); /*clean up any dangling fgon flags*/ - for (e=BMIter_New(&iter, bm, BM_EDGES, NULL); e; e=BMIter_Step(&iter)){ + for (e=BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL); e; e=BMIter_Step(&iter)){ e->head.flag &= ~BM_FGON; } @@ -441,7 +441,7 @@ BMesh *editmesh_to_bmesh_intern(EditMesh *em, BMesh *bm, BMOperator *op) { void edit2bmesh_exec(BMesh *bmesh, BMOperator *op) { - editmesh_to_bmesh_intern(op->slots[BMOP_FROM_EDITMESH_EM].data.p, bmesh, op); + editmesh_to_bmesh_intern(BMO_Get_Pnt(op, "em"), bmesh, op); } BMesh *editmesh_to_bmesh(EditMesh *em) @@ -453,8 +453,8 @@ BMesh *editmesh_to_bmesh(EditMesh *em) /*allocate a bmesh*/ bm = BM_Make_Mesh(allocsize); - BMO_Init_Op(&conv, BMOP_FROM_EDITMESH); - BMO_Set_Pnt(&conv, BMOP_FROM_EDITMESH_EM, em); + BMO_Init_Op(&conv, "editmesh_to_bmesh"); + BMO_Set_Pnt(&conv, "em", em); BMO_Exec_Op(bm, &conv); BMO_Finish_Op(bm, &conv); @@ -469,8 +469,8 @@ BMesh *init_editmesh_to_bmesh(EditMesh *em, BMOperator *op) /*allocate a bmesh*/ bm = BM_Make_Mesh(allocsize); - BMO_Init_Op(op, BMOP_FROM_EDITMESH); - BMO_Set_Pnt(op, BMOP_FROM_EDITMESH_EM, em); + BMO_Init_Op(op, "editmesh_to_bmesh"); + BMO_Set_Pnt(op, "em", em); return bm; } \ No newline at end of file diff --git a/source/blender/bmesh/operators/bmesh_dupeops.c b/source/blender/bmesh/operators/bmesh_dupeops.c index c27b7dc8b3b..eb4188b6f40 100644 --- a/source/blender/bmesh/operators/bmesh_dupeops.c +++ b/source/blender/bmesh/operators/bmesh_dupeops.c @@ -61,7 +61,7 @@ static BMEdge *copy_edge(BMOperator *op, BMesh *source_mesh, not being duplicated. in that case, add it to the new/old map.*/ rlen = 0; - for (face=BMIter_New(&fiter,source_mesh, BM_FACES_OF_EDGE,source_edge); + for (face=BMIter_New(&fiter,source_mesh, BM_FACES_OF_MESH_OF_EDGE,source_edge); face; face=BMIter_Step(&fiter)) { if (BMO_TestFlag(source_mesh, face, DUPE_INPUT)) { rlen++; @@ -79,7 +79,7 @@ static BMEdge *copy_edge(BMOperator *op, BMesh *source_mesh, if (rlen < 2) { /*not sure what non-manifold cases of greater then three radial should do.*/ - BMO_Insert_MapPointer(source_mesh,op,BMOP_DUPE_BOUNDS_EDGEMAP, + BMO_Insert_MapPointer(source_mesh,op, "boundarymap", source_edge, target_edge); } @@ -110,7 +110,7 @@ static BMFace *copy_face(BMesh *source_mesh, BMFace *source_face, BMesh *target_ int i; /*lookup the first and second verts*/ - target_vert1 = BLI_ghash_lookup(vhash, BMIter_New(&iter, source_mesh, BM_VERTS_OF_FACE, source_face)); + target_vert1 = BLI_ghash_lookup(vhash, BMIter_New(&iter, source_mesh, BM_VERTS_OF_MESH_OF_FACE, source_face)); target_vert2 = BLI_ghash_lookup(vhash, BMIter_Step(&iter)); /*lookup edges*/ @@ -166,16 +166,16 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target) ehash = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp); /*initialize edge pointer array*/ - for(f = BMIter_New(&faces, source, BM_FACES, source); f; f = BMIter_Step(&faces)){ + for(f = BMIter_New(&faces, source, BM_FACES_OF_MESH, source); f; f = BMIter_Step(&faces)){ if(f->len > maxlength) maxlength = f->len; } edar = MEM_callocN(sizeof(BMEdge*) * maxlength, "BM copy mesh edge pointer array"); /*first we dupe all flagged faces and their elements from source*/ - for(f = BMIter_New(&faces, source, BM_FACES, source); f; f= BMIter_Step(&faces)){ + for(f = BMIter_New(&faces, source, BM_FACES_OF_MESH, source); f; f= BMIter_Step(&faces)){ if(BMO_TestFlag(source, (BMHeader*)f, DUPE_INPUT)){ /*vertex pass*/ - for(v = BMIter_New(&verts, source, BM_VERTS_OF_FACE, f); v; v = BMIter_Step(&verts)){ + for(v = BMIter_New(&verts, source, BM_VERTS_OF_MESH_OF_FACE, f); v; v = BMIter_Step(&verts)){ if(!BMO_TestFlag(source, (BMHeader*)v, DUPE_DONE)){ copy_vertex(source,v, target, vhash); BMO_SetFlag(source, (BMHeader*)v, DUPE_DONE); @@ -183,7 +183,7 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target) } /*edge pass*/ - for(e = BMIter_New(&edges, source, BM_EDGES_OF_FACE, f); e; e = BMIter_Step(&edges)){ + for(e = BMIter_New(&edges, source, BM_EDGES_OF_MESH_OF_FACE, f); e; e = BMIter_Step(&edges)){ if(!BMO_TestFlag(source, (BMHeader*)e, DUPE_DONE)){ copy_edge(op, source, e, target, vhash, ehash); BMO_SetFlag(source, (BMHeader*)e, DUPE_DONE); @@ -195,7 +195,7 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target) } /*now we dupe all the edges*/ - for(e = BMIter_New(&edges, source, BM_EDGES, source); e; e = BMIter_Step(&edges)){ + for(e = BMIter_New(&edges, source, BM_EDGES_OF_MESH, source); e; e = BMIter_Step(&edges)){ if(BMO_TestFlag(source, (BMHeader*)e, DUPE_INPUT) && (!BMO_TestFlag(source, (BMHeader*)e, DUPE_DONE))){ /*make sure that verts are copied*/ if(!BMO_TestFlag(source, (BMHeader*)e->v1, DUPE_DONE)) { @@ -213,11 +213,11 @@ static void copy_mesh(BMOperator *op, BMesh *source, BMesh *target) } /*finally dupe all loose vertices*/ - for(v = BMIter_New(&verts, source, BM_VERTS, source); v; v = BMIter_Step(&verts)){ + for(v = BMIter_New(&verts, source, BM_VERTS_OF_MESH, source); v; v = BMIter_Step(&verts)){ if(BMO_TestFlag(source, (BMHeader*)v, DUPE_INPUT) && (!BMO_TestFlag(source, (BMHeader*)v, DUPE_DONE))){ v2 = copy_vertex(source, v, target, vhash); BMO_Insert_MapPointer(source, op, - BMOP_DUPE_ISOLATED_VERTS_MAP, v, v2); + "isovertmap", v, v2); BMO_SetFlag(source, (BMHeader*)v, DUPE_DONE); } } @@ -289,16 +289,16 @@ void dupeop_exec(BMesh *bm, BMOperator *op) BMOperator *dupeop = op; /*flag input*/ - BMO_Flag_Buffer(bm, dupeop, BMOP_DUPE_MULTIN, DUPE_INPUT); + BMO_Flag_Buffer(bm, dupeop, "geom", DUPE_INPUT); /*use the internal copy function*/ copy_mesh(dupeop, bm, bm); /*Output*/ /*First copy the input buffers to output buffers - original data*/ - BMO_CopySlot(dupeop, dupeop, BMOP_DUPE_MULTIN, BMOP_DUPE_ORIG); + BMO_CopySlot(dupeop, dupeop, "geom", "origout"); /*Now alloc the new output buffers*/ - BMO_Flag_To_Slot(bm, dupeop, BMOP_DUPE_NEW, DUPE_NEW, BM_VERT|BM_EDGE|BM_FACE); + BMO_Flag_To_Slot(bm, dupeop, "newout", DUPE_NEW, BM_ALL); } /*executes the duplicate operation, feeding elements of @@ -309,8 +309,8 @@ void BMOP_DupeFromFlag(BMesh *bm, int etypeflag, int flag) { BMOperator dupeop; - BMO_Init_Op(&dupeop, BMOP_DUPE); - BMO_HeaderFlag_To_Slot(bm, &dupeop, BMOP_DUPE_MULTIN, flag, etypeflag); + BMO_Init_Op(&dupeop, "dupe"); + BMO_HeaderFlag_To_Slot(bm, &dupeop, "geom", flag, etypeflag); BMO_Exec_Op(bm, &dupeop); BMO_Finish_Op(bm, &dupeop); @@ -348,18 +348,18 @@ void splitop_exec(BMesh *bm, BMOperator *op) int found; /*initialize our sub-operators*/ - BMO_Init_Op(&dupeop, BMOP_DUPE); - BMO_Init_Op(&delop, BMOP_DEL); + BMO_Init_Op(&dupeop, "dupe"); + BMO_Init_Op(&delop, "del"); - BMO_CopySlot(splitop, &dupeop, BMOP_SPLIT_MULTIN, BMOP_DUPE_MULTIN); + BMO_CopySlot(splitop, &dupeop, "geom", "geom"); BMO_Exec_Op(bm, &dupeop); - BMO_Flag_Buffer(bm, splitop, BMOP_SPLIT_MULTIN, SPLIT_INPUT); + BMO_Flag_Buffer(bm, splitop, "geom", SPLIT_INPUT); /*make sure to remove edges and verts we don't need.*/ - for (e= BMIter_New(&iter, bm, BM_EDGES, NULL);e;e=BMIter_Step(&iter)) { + for (e= BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL);e;e=BMIter_Step(&iter)) { found = 0; - f = BMIter_New(&iter2, bm, BM_FACES_OF_EDGE, e); + f = BMIter_New(&iter2, bm, BM_FACES_OF_MESH_OF_EDGE, e); for (; f; f=BMIter_Step(&iter2)) { if (!BMO_TestFlag(bm, f, SPLIT_INPUT)) { found = 1; @@ -369,9 +369,9 @@ void splitop_exec(BMesh *bm, BMOperator *op) if (!found) BMO_SetFlag(bm, e, SPLIT_INPUT); } - for (v= BMIter_New(&iter, bm, BM_VERTS, NULL);v;v=BMIter_Step(&iter)) { + for (v= BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL);v;v=BMIter_Step(&iter)) { found = 0; - e = BMIter_New(&iter2, bm, BM_EDGES_OF_VERT, v); + e = BMIter_New(&iter2, bm, BM_EDGES_OF_MESH_OF_VERT, v); for (; e; e=BMIter_Step(&iter2)) { if (!BMO_TestFlag(bm, e, SPLIT_INPUT)) { found = 1; @@ -383,17 +383,17 @@ void splitop_exec(BMesh *bm, BMOperator *op) } /*connect outputs of dupe to delete, exluding keep geometry*/ - BMO_Set_Int(&delop, BMOP_DEL_CONTEXT, DEL_FACES); - BMO_Flag_To_Slot(bm, &delop, BMOP_DEL_MULTIN, SPLIT_INPUT, BM_ALL); + BMO_Set_Int(&delop, "context", DEL_FACES); + BMO_Flag_To_Slot(bm, &delop, "geom", SPLIT_INPUT, BM_ALL); BMO_Exec_Op(bm, &delop); /*now we make our outputs by copying the dupe outputs*/ - BMO_CopySlot(&dupeop, splitop, BMOP_DUPE_NEW, BMOP_SPLIT_MULTOUT); - BMO_CopySlot(&dupeop, splitop, BMOP_DUPE_BOUNDS_EDGEMAP, - BMOP_SPLIT_BOUNDS_EDGEMAP); - BMO_CopySlot(&dupeop, splitop, BMOP_DUPE_ISOLATED_VERTS_MAP, - BMOP_SPLIT_ISOLATED_VERTS_MAP); + BMO_CopySlot(&dupeop, splitop, "newout", "geom"); + BMO_CopySlot(&dupeop, splitop, "boundarymap", + "boundarymap"); + BMO_CopySlot(&dupeop, splitop, "isovertmap", + "isovertmap"); /*cleanup*/ BMO_Finish_Op(bm, &delop); @@ -411,9 +411,9 @@ void delop_exec(BMesh *bm, BMOperator *op) BMOperator *delop = op; /*Mark Buffers*/ - BMO_Flag_Buffer(bm, delop, BMOP_DEL_MULTIN, DEL_INPUT); + BMO_Flag_Buffer(bm, delop, "geom", DEL_INPUT); - delete_context(bm, op->slots[BMOP_DEL_CONTEXT].data.i); + delete_context(bm, BMO_Get_Int(op, "context")); } static void delete_verts(BMesh *bm) @@ -426,13 +426,13 @@ static void delete_verts(BMesh *bm) BMIter edges; BMIter faces; - for(v = BMIter_New(&verts, bm, BM_VERTS, bm); v; v = BMIter_Step(&verts)){ + for(v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts)){ if(BMO_TestFlag(bm, (BMHeader*)v, DEL_INPUT)) { /*Visit edges*/ - for(e = BMIter_New(&edges, bm, BM_EDGES_OF_VERT, v); e; e = BMIter_Step(&edges)) + for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH_OF_VERT, v); e; e = BMIter_Step(&edges)) BMO_SetFlag(bm, (BMHeader*)e, DEL_INPUT); /*Visit faces*/ - for(f = BMIter_New(&faces, bm, BM_FACES_OF_VERT, v); f; f = BMIter_Step(&faces)) + for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH_OF_VERT, v); f; f = BMIter_Step(&faces)) BMO_SetFlag(bm, (BMHeader*)f, DEL_INPUT); } } @@ -449,9 +449,9 @@ static void delete_edges(BMesh *bm){ BMIter edges; BMIter faces; - for(e = BMIter_New(&edges, bm, BM_EDGES, bm); e; e = BMIter_Step(&edges)){ + for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)){ if(BMO_TestFlag(bm, (BMHeader*)e, DEL_INPUT)) { - for(f = BMIter_New(&faces, bm, BM_FACES_OF_EDGE, e); f; f = BMIter_Step(&faces)){ + for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH_OF_EDGE, e); f; f = BMIter_Step(&faces)){ BMO_SetFlag(bm, (BMHeader*)f, DEL_INPUT); } } @@ -482,7 +482,7 @@ static void delete_context(BMesh *bm, int type){ if(type == DEL_VERTS) delete_verts(bm); else if(type == DEL_EDGES){ /*flush down to verts*/ - for(e = BMIter_New(&edges, bm, BM_EDGES, bm); e; e = BMIter_Step(&edges)){ + for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)){ if(BMO_TestFlag(bm, (BMHeader*)e, DEL_INPUT)){ BMO_SetFlag(bm, (BMHeader*)(e->v1), DEL_INPUT); BMO_SetFlag(bm, (BMHeader*)(e->v2), DEL_INPUT); @@ -490,7 +490,7 @@ static void delete_context(BMesh *bm, int type){ } delete_edges(bm); /*remove loose vertices*/ - for(v = BMIter_New(&verts, bm, BM_VERTS, bm); v; v = BMIter_Step(&verts)){ + for(v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts)){ if(BMO_TestFlag(bm, (BMHeader*)v, DEL_INPUT) && (!(v->edge))) BMO_SetFlag(bm, (BMHeader*)v, DEL_WIREVERT); } @@ -504,20 +504,20 @@ static void delete_context(BMesh *bm, int type){ BM_remove_tagged_verts(bm, DEL_INPUT); } else if(type == DEL_FACES){ /*go through and mark all edges and all verts of all faces for delete*/ - for(f = BMIter_New(&faces, bm, BM_FACES, bm); f; f = BMIter_Step(&faces)){ + for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)){ if(BMO_TestFlag(bm, (BMHeader*)f, DEL_INPUT)){ - for(e = BMIter_New(&edges, bm, BM_EDGES_OF_FACE, f); e; e = BMIter_Step(&edges)) + for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH_OF_FACE, f); e; e = BMIter_Step(&edges)) BMO_SetFlag(bm, (BMHeader*)e, DEL_INPUT); - for(v = BMIter_New(&verts, bm, BM_VERTS_OF_FACE, f); v; v = BMIter_Step(&verts)) + for(v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH_OF_FACE, f); v; v = BMIter_Step(&verts)) BMO_SetFlag(bm, (BMHeader*)v, DEL_INPUT); } } /*now go through and mark all remaining faces all edges for keeping.*/ - for(f = BMIter_New(&faces, bm, BM_FACES, bm); f; f = BMIter_Step(&faces)){ + for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)){ if(!BMO_TestFlag(bm, (BMHeader*)f, DEL_INPUT)){ - for(e = BMIter_New(&edges, bm, BM_EDGES_OF_FACE, f); e; e= BMIter_Step(&edges)) + for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH_OF_FACE, f); e; e= BMIter_Step(&edges)) BMO_ClearFlag(bm, (BMHeader*)e, DEL_INPUT); - for(v = BMIter_New(&verts, bm, BM_VERTS_OF_FACE, f); v; v= BMIter_Step(&verts)) + for(v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH_OF_FACE, f); v; v= BMIter_Step(&verts)) BMO_ClearFlag(bm, (BMHeader*)v, DEL_INPUT); } } @@ -530,11 +530,11 @@ static void delete_context(BMesh *bm, int type){ } /*does this option even belong in here?*/ else if(type == DEL_ALL){ - for(f = BMIter_New(&faces, bm, BM_FACES, bm); f; f = BMIter_Step(&faces)) + for(f = BMIter_New(&faces, bm, BM_FACES_OF_MESH, bm); f; f = BMIter_Step(&faces)) BMO_SetFlag(bm, (BMHeader*)f, DEL_INPUT); - for(e = BMIter_New(&edges, bm, BM_EDGES, bm); e; e = BMIter_Step(&edges)) + for(e = BMIter_New(&edges, bm, BM_EDGES_OF_MESH, bm); e; e = BMIter_Step(&edges)) BMO_SetFlag(bm, (BMHeader*)e, DEL_INPUT); - for(v = BMIter_New(&verts, bm, BM_VERTS, bm); v; v = BMIter_Step(&verts)) + for(v = BMIter_New(&verts, bm, BM_VERTS_OF_MESH, bm); v; v = BMIter_Step(&verts)) BMO_SetFlag(bm, (BMHeader*)v, DEL_INPUT); BM_remove_tagged_faces(bm, DEL_INPUT); diff --git a/source/blender/bmesh/operators/connectops.c b/source/blender/bmesh/operators/connectops.c index 0246c23153b..a8f5899fd65 100644 --- a/source/blender/bmesh/operators/connectops.c +++ b/source/blender/bmesh/operators/connectops.c @@ -25,9 +25,9 @@ void connectverts_exec(BMesh *bm, BMOperator *op) V_DECLARE(verts); int i; - BMO_Flag_Buffer(bm, op, BM_CONVERTS_VERTIN, VERT_INPUT); + BMO_Flag_Buffer(bm, op, "verts", VERT_INPUT); - for (f=BMIter_New(&iter, bm, BM_FACES, NULL); f; f=BMIter_Step(&iter)){ + for (f=BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL); f; f=BMIter_Step(&iter)){ V_RESET(loops); V_RESET(verts); @@ -95,7 +95,7 @@ void connectverts_exec(BMesh *bm, BMOperator *op) } } - BMO_Flag_To_Slot(bm, op, BM_CONVERTS_EDGEOUT, EDGE_OUT, BM_EDGE); + BMO_Flag_To_Slot(bm, op, "edgeout", EDGE_OUT, BM_EDGE); V_FREE(loops); V_FREE(verts); @@ -107,12 +107,12 @@ int BM_ConnectVerts(EditMesh *em, int flag) BMesh *bm = editmesh_to_bmesh(em); BMOperator op; - BMO_Init_Op(&op, BMOP_CONNECT_VERTS); - BMO_HeaderFlag_To_Slot(bm, &op, BM_CONVERTS_VERTIN, flag, BM_VERT); + BMO_Init_Op(&op, "connectverts"); + BMO_HeaderFlag_To_Slot(bm, &op, "verts", flag, BM_VERT); BMO_Exec_Op(bm, &op); BMO_Finish_Op(bm, &op); - if (BMO_GetSlot(&op, BM_CONVERTS_EDGEOUT)->len > 0 && + if (BMO_GetSlot(&op, "edgeout")->len > 0 && BMO_GetError(bm, NULL, NULL)==0) { em2 = bmesh_to_editmesh(bm); diff --git a/source/blender/bmesh/operators/dissolveops.c b/source/blender/bmesh/operators/dissolveops.c index ee7bd6ee709..4c9fcb167f3 100644 --- a/source/blender/bmesh/operators/dissolveops.c +++ b/source/blender/bmesh/operators/dissolveops.c @@ -59,10 +59,10 @@ void dissolvefaces_exec(BMesh *bm, BMOperator *op) BMWalker regwalker; int i, j, fcopied; - BMO_Flag_Buffer(bm, op, BMOP_DISFACES_FACEIN, FACE_MARK); + BMO_Flag_Buffer(bm, op, "faces", FACE_MARK); /*collect regions*/ - f = BMO_IterNew(&oiter, bm, op, BMOP_DISFACES_FACEIN); + f = BMO_IterNew(&oiter, bm, op, "faces"); for (; f; f=BMO_IterStep(&oiter)) { if (!BMO_TestFlag(bm, f, FACE_MARK)) continue; @@ -132,6 +132,8 @@ void dissolvefaces_exec(BMesh *bm, BMOperator *op) f= BM_Make_Ngon(bm, region[0]->e->v1, region[0]->e->v2, edges, j, 1); else f= BM_Make_Ngon(bm, region[0]->e->v2, region[0]->e->v1, edges, j, 1); + + V_FREE(edges); if (!f) { BMO_RaiseError(bm, op, BMERR_DISSOLVEFACES_FAILED, @@ -175,7 +177,7 @@ void dissolvefaces_exec(BMesh *bm, BMOperator *op) BMO_CallOpf(bm, "del geom=%ff context=%d", FACE_ORIG, DEL_FACES); if (BMO_HasError(bm)) goto cleanup; - BMO_Flag_To_Slot(bm, op, BMOP_DISFACES_REGIONOUT, FACE_NEW, BM_FACE); + BMO_Flag_To_Slot(bm, op, "regionout", FACE_NEW, BM_FACE); cleanup: /*free/cleanup*/ @@ -196,7 +198,7 @@ static int test_extra_verts(BMesh *bm, BMVert *v) /*test faces around verts for verts that would be wronly killed by dissolve faces.*/ - f = BMIter_New(&iter, bm, BM_FACES_OF_VERT, v); + f = BMIter_New(&iter, bm, BM_FACES_OF_MESH_OF_VERT, v); for (; f; f=BMIter_Step(&iter)) { l=BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f); for (; l; l=BMIter_Step(&liter)) { @@ -206,10 +208,10 @@ static int test_extra_verts(BMesh *bm, BMVert *v) also if it forms a boundary with one of the face regions*/ found = 0; - e = BMIter_New(&iter2, bm, BM_EDGES_OF_VERT, l->v); + e = BMIter_New(&iter2, bm, BM_EDGES_OF_MESH_OF_VERT, l->v); for (; e; e=BMIter_Step(&iter2)) { if (BM_Edge_FaceCount(e)==1) found = 1; - f2 = BMIter_New(&iter3, bm, BM_FACES_OF_EDGE, e); + f2 = BMIter_New(&iter3, bm, BM_FACES_OF_MESH_OF_EDGE, e); for (; f2; f2=BMIter_Step(&iter3)) { if (!BMO_TestFlag(bm, f2, FACE_MARK)) { found = 1; @@ -233,13 +235,12 @@ void dissolveverts_exec(BMesh *bm, BMOperator *op) BMFace *f; int i; - vinput = BMO_GetSlot(op, BMOP_DISVERTS_VERTIN); - - BMO_Flag_Buffer(bm, op, BMOP_DISVERTS_VERTIN, VERT_MARK); + vinput = BMO_GetSlot(op, "verts"); + BMO_Flag_Buffer(bm, op, "verts", VERT_MARK); - for (v=BMIter_New(&iter, bm, BM_VERTS, NULL); v; v=BMIter_Step(&iter)) { + for (v=BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); v; v=BMIter_Step(&iter)) { if (BMO_TestFlag(bm, v, VERT_MARK)) { - f=BMIter_New(&fiter, bm, BM_FACES_OF_VERT, v); + f=BMIter_New(&fiter, bm, BM_FACES_OF_MESH_OF_VERT, v); for (; f; f=BMIter_Step(&fiter)) { BMO_SetFlag(bm, f, FACE_ORIG); BMO_SetFlag(bm, f, FACE_MARK); @@ -248,7 +249,7 @@ void dissolveverts_exec(BMesh *bm, BMOperator *op) /*check if our additions to the input to face dissolve will destroy nonmarked vertices.*/ if (!test_extra_verts(bm, v)) { - f=BMIter_New(&fiter, bm, BM_FACES_OF_VERT, v); + f=BMIter_New(&fiter, bm, BM_FACES_OF_MESH_OF_VERT, v); for (; f; f=BMIter_Step(&fiter)) { if (BMO_TestFlag(bm, f, FACE_ORIG)) { BMO_ClearFlag(bm, f, FACE_MARK); @@ -256,7 +257,7 @@ void dissolveverts_exec(BMesh *bm, BMOperator *op) } } } else { - f=BMIter_New(&fiter, bm, BM_FACES_OF_VERT, v); + f=BMIter_New(&fiter, bm, BM_FACES_OF_MESH_OF_VERT, v); for (; f; f=BMIter_Step(&fiter)) { BMO_ClearFlag(bm, f, FACE_ORIG); } @@ -274,7 +275,7 @@ void dissolveverts_exec(BMesh *bm, BMOperator *op) } /*clean up any remaining*/ - for (v=BMIter_New(&iter, bm, BM_VERTS, NULL); v; v=BMIter_Step(&iter)) { + for (v=BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); v; v=BMIter_Step(&iter)) { if (BMO_TestFlag(bm, v, VERT_MARK)) { if (!BM_Dissolve_Vert(bm, v)) { BMO_RaiseError(bm, op, @@ -296,7 +297,7 @@ void dissolveverts_exec(BMesh *bm, BMOperator *op) found3 = 1; while (found3) { found3 = 0; - for (f=BMIter_New(&iter, bm, BM_FACES, NULL); f; f=BMIter_Step(&iter)){ + for (f=BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL); f; f=BMIter_Step(&iter)){ if (!BM_Validate_Face(bm, f, stderr)) { printf("error.\n"); } @@ -312,7 +313,7 @@ void dissolveverts_exec(BMesh *bm, BMOperator *op) fe = l->e; for (; l; l=BMIter_Step(&liter)) { f2 = BMIter_New(&fiter, bm, - BM_FACES_OF_EDGE, l->e); + BM_FACES_OF_MESH_OF_EDGE, l->e); for (; f2; f2=BMIter_Step(&fiter)) { if (f2 != f) { BM_Join_Faces(bm, f, f2, l->e); diff --git a/source/blender/bmesh/operators/extrudeops.c b/source/blender/bmesh/operators/extrudeops.c index 3fa3161328c..445e0b56d25 100644 --- a/source/blender/bmesh/operators/extrudeops.c +++ b/source/blender/bmesh/operators/extrudeops.c @@ -26,17 +26,17 @@ void extrude_edge_context_exec(BMesh *bm, BMOperator *op) int rlen, found, delorig=0, i, reverse; /*initialize our sub-operators*/ - BMO_Init_Op(&dupeop, BMOP_DUPE); + BMO_Init_Op(&dupeop, "dupe"); - BMO_Flag_Buffer(bm, op, BMOP_EXFACE_EDGEFACEIN, EXT_INPUT); + BMO_Flag_Buffer(bm, op, "edgefacein", EXT_INPUT); /*if one flagged face is bordered by an unflagged face, then we delete original geometry.*/ - for (e=BMIter_New(&iter, bm, BM_EDGES, NULL);e;e=BMIter_Step(&iter)) { + for (e=BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL);e;e=BMIter_Step(&iter)) { if (!BMO_TestFlag(bm, e, EXT_INPUT)) continue; found = 0; - f = BMIter_New(&fiter, bm, BM_FACES_OF_EDGE, e); + f = BMIter_New(&fiter, bm, BM_FACES_OF_MESH_OF_EDGE, e); for (rlen=0; f; f=BMIter_Step(&fiter), rlen++) { if (!BMO_TestFlag(bm, f, EXT_INPUT)) { found = 1; @@ -49,7 +49,7 @@ void extrude_edge_context_exec(BMesh *bm, BMOperator *op) } /*calculate verts to delete*/ - for (v = BMIter_New(&iter, bm, BM_VERTS, NULL); v; v=BMIter_Step(&iter)) { + for (v = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); v; v=BMIter_Step(&iter)) { found = 0; l = BMIter_New(&viter, bm, BM_LOOPS_OF_VERT, v); @@ -71,31 +71,31 @@ void extrude_edge_context_exec(BMesh *bm, BMOperator *op) } } - for (f=BMIter_New(&fiter, bm, BM_FACES, NULL); f; f=BMIter_Step(&fiter)) { + for (f=BMIter_New(&fiter, bm, BM_FACES_OF_MESH, NULL); f; f=BMIter_Step(&fiter)) { if (BMO_TestFlag(bm, f, EXT_INPUT)) BMO_SetFlag(bm, f, EXT_DEL); } if (delorig) BMO_InitOpf(bm, &delop, "del geom=%fvef context=%d", EXT_DEL, DEL_ONLYTAGGED); - BMO_CopySlot(op, &dupeop, BMOP_EXFACE_EDGEFACEIN, BMOP_DUPE_MULTIN); + BMO_CopySlot(op, &dupeop, "edgefacein", "geom"); BMO_Exec_Op(bm, &dupeop); if (delorig) BMO_Exec_Op(bm, &delop); /*if not delorig, reverse loops of original faces*/ if (!delorig) { - for (f=BMIter_New(&iter, bm, BM_FACES, NULL); f; f=BMIter_Step(&iter)) { + for (f=BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL); f; f=BMIter_Step(&iter)) { if (BMO_TestFlag(bm, f, EXT_INPUT)) { BM_flip_normal(bm, f); } } } - BMO_CopySlot(&dupeop, op, BMOP_DUPE_NEW, BMOP_EXFACE_MULTOUT); - e = BMO_IterNew(&siter, bm, &dupeop, BMOP_DUPE_BOUNDS_EDGEMAP); + BMO_CopySlot(&dupeop, op, "newout", "geomout"); + e = BMO_IterNew(&siter, bm, &dupeop, "boundarymap"); for (; e; e=BMO_IterStep(&siter)) { - if (BMO_InMap(bm, op, BMOP_EXFACE_EXCLUDEMAP, e)) continue; + if (BMO_InMap(bm, op, "exclude", e)) continue; newedge = BMO_IterMapVal(&siter); newedge = *(BMEdge**)newedge; @@ -153,7 +153,7 @@ void extrude_edge_context_exec(BMesh *bm, BMOperator *op) } /*link isolated verts*/ - v = BMO_IterNew(&siter, bm, &dupeop, BMOP_DUPE_ISOLATED_VERTS_MAP); + v = BMO_IterNew(&siter, bm, &dupeop, "isovertmap"); for (; v; v=BMO_IterStep(&siter)) { v2 = *((void**)BMO_IterMapVal(&siter)); BM_Make_Edge(bm, v, v2, v->edge, 1); diff --git a/source/blender/bmesh/operators/subdivideop.c b/source/blender/bmesh/operators/subdivideop.c index b7f12344e2f..23e00dba037 100644 --- a/source/blender/bmesh/operators/subdivideop.c +++ b/source/blender/bmesh/operators/subdivideop.c @@ -64,8 +64,8 @@ BMEdge *connect_smallest_face(BMesh *bm, BMVert *v1, BMVert *v2, BMFace **nf) { /*this isn't the best thing in the world. it doesn't handle cases where there's multiple faces yet. that might require a convexity test to figure out which face is "best," and who knows what for non-manifold conditions.*/ - for (face = BMIter_New(&iter, bm, BM_FACES_OF_VERT, v1); face; face=BMIter_Step(&iter)) { - for (v=BMIter_New(&iter2, bm, BM_VERTS_OF_FACE, face); v; v=BMIter_Step(&iter2)) { + for (face = BMIter_New(&iter, bm, BM_FACES_OF_MESH_OF_VERT, v1); face; face=BMIter_Step(&iter)) { + for (v=BMIter_New(&iter2, bm, BM_VERTS_OF_MESH_OF_FACE, face); v; v=BMIter_Step(&iter2)) { if (v == v2) { if (!curf || face->len < curf->len) curf = face; } @@ -183,7 +183,7 @@ static BMVert *subdivideedgenum(BMesh *bm, BMEdge *edge, BMEdge *oedge, if (BMO_TestFlag(bm, edge, EDGE_PERCENT) && totpoint == 1) percent = BMO_Get_MapFloat(bm, params->op, - BMOP_ESUBDIVIDE_PERCENT_EDGEMAP, edge); + "edgepercents", edge); else { percent= 1.0f/(float)(totpoint+1-curpoint); percent2 = (float)curpoint / (float)(totpoint + 1); @@ -625,16 +625,16 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) float rad; int i, j, matched, a, b, numcuts, flag; - BMO_Flag_Buffer(bmesh, op, BMOP_ESUBDIVIDE_EDGES, SUBD_SPLIT); + BMO_Flag_Buffer(bmesh, op, "edges", SUBD_SPLIT); - numcuts = BMO_GetSlot(op, BMOP_ESUBDIVIDE_NUMCUTS)->data.i; - flag = BMO_GetSlot(op, BMOP_ESUBDIVIDE_FLAG)->data.i; - rad = BMO_GetSlot(op, BMOP_ESUBDIVIDE_RADIUS)->data.f; + numcuts = BMO_GetSlot(op, "numcuts")->data.i; + flag = BMO_GetSlot(op, "flag")->data.i; + rad = BMO_GetSlot(op, "radius")->data.f; - einput = BMO_GetSlot(op, BMOP_ESUBDIVIDE_EDGES); + einput = BMO_GetSlot(op, "edges"); /*first go through and tag edges*/ - BMO_Flag_To_Slot(bmesh, op, BMOP_ESUBDIVIDE_EDGES, + BMO_Flag_To_Slot(bmesh, op, "edges", SUBD_SPLIT, BM_EDGE); params.flag = flag; @@ -642,13 +642,13 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) params.op = op; params.rad = rad; - BMO_Mapping_To_Flag(bmesh, op, BMOP_ESUBDIVIDE_CUSTOMFILL_FACEMAP, + BMO_Mapping_To_Flag(bmesh, op, "custompatterns", FACE_CUSTOMFILL); - BMO_Mapping_To_Flag(bmesh, op, BMOP_ESUBDIVIDE_PERCENT_EDGEMAP, + BMO_Mapping_To_Flag(bmesh, op, "edgepercents", EDGE_PERCENT); - for (face=BMIter_New(&fiter, bmesh, BM_FACES, NULL); + for (face=BMIter_New(&fiter, bmesh, BM_FACES_OF_MESH, NULL); face; face=BMIter_Step(&fiter)) { /*figure out which pattern to use*/ @@ -666,7 +666,7 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) if (BMO_TestFlag(bmesh, face, FACE_CUSTOMFILL)) { pat = BMO_Get_MapData(bmesh, op, - BMOP_ESUBDIVIDE_CUSTOMFILL_FACEMAP, face); + "custompatterns", face); for (i=0; ilen; i++) { matched = 1; for (j=0; jlen; j++) { @@ -722,7 +722,7 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) } } - einput = BMO_GetSlot(op, BMOP_ESUBDIVIDE_EDGES); + einput = BMO_GetSlot(op, "edges"); /*go through and split edges*/ for (i=0; ilen; i++) { @@ -735,7 +735,7 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) //return; i = 0; - for (face=BMIter_New(&fiter, bmesh, BM_FACES, NULL); + for (face=BMIter_New(&fiter, bmesh, BM_FACES_OF_MESH, NULL); face; face=BMIter_Step(&fiter)) { /*figure out which pattern to use*/ V_RESET(verts); @@ -774,9 +774,9 @@ void esubdivide_exec(BMesh *bmesh, BMOperator *op) if (edges) V_FREE(edges); if (verts) V_FREE(verts); - BMO_Flag_To_Slot(bmesh, op, BMOP_ESUBDIVIDE_INNER_MULTOUT, + BMO_Flag_To_Slot(bmesh, op, "outinner", ELE_INNER, BM_ALL); - BMO_Flag_To_Slot(bmesh, op, BMOP_ESUBDIVIDE_SPLIT_MULTOUT, + BMO_Flag_To_Slot(bmesh, op, "outsplit", ELE_SPLIT, BM_ALL); } @@ -795,7 +795,7 @@ void BM_esubdivideflag(Object *obedit, BMesh *bm, int selflag, float rad, BMHeader *ele; int i; - ele = BMO_IterNew(&iter,bm,&op,BMOP_ESUBDIVIDE_INNER_MULTOUT); + ele = BMO_IterNew(&iter,bm,&op, "outinner"); for (; ele; ele=BMO_IterStep(&iter)) { BM_Select(bm, ele, 1); } diff --git a/source/blender/bmesh/operators/triangulateop.c b/source/blender/bmesh/operators/triangulateop.c index 5f46577945c..e64ffa9539d 100644 --- a/source/blender/bmesh/operators/triangulateop.c +++ b/source/blender/bmesh/operators/triangulateop.c @@ -22,7 +22,7 @@ void triangulate_exec(BMesh *bm, BMOperator *op) V_DECLARE(projectverts); int i, lastlen=0, count = 0; - face = BMO_IterNew(&siter, bm, op, BMOP_TRIANG_FACEIN); + face = BMO_IterNew(&siter, bm, op, "faces"); for (; face; face=BMO_IterStep(&siter)) { if (lastlen < face->len) { V_RESET(projectverts); @@ -38,17 +38,18 @@ void triangulate_exec(BMesh *bm, BMOperator *op) BM_Triangulate_Face(bm, face, projectverts, EDGE_NEW, FACE_NEW, newfaces); - BMO_Insert_MapPointer(bm, op, BMOP_TRIANG_FACEMAP, + BMO_Insert_MapPointer(bm, op, "facemap", face, face); for (i=0; newfaces[i]; i++) { - BMO_Insert_MapPointer(bm, op, BMOP_TRIANG_FACEMAP, + BMO_Insert_MapPointer(bm, op, "facemap", newfaces[i], face); } } - BMO_Flag_To_Slot(bm, op, BMOP_TRIANG_NEW_EDGES, EDGE_NEW, BM_EDGE); - BMO_Flag_To_Slot(bm, op, BMOP_TRIANG_NEW_FACES, FACE_NEW, BM_FACE); + BMO_Flag_To_Slot(bm, op, "edgeout", EDGE_NEW, BM_EDGE); + BMO_Flag_To_Slot(bm, op, "faceout", FACE_NEW, BM_FACE); V_FREE(projectverts); + V_FREE(newfaces); } \ No newline at end of file diff --git a/source/blender/editors/mesh/editmesh_add.c b/source/blender/editors/mesh/editmesh_add.c index 8f7214d08a3..398cee48e9f 100644 --- a/source/blender/editors/mesh/editmesh_add.c +++ b/source/blender/editors/mesh/editmesh_add.c @@ -682,7 +682,7 @@ static void addedgeface_mesh(EditMesh *em, wmOperator *op) ok = EDBM_Finish(bm, em, op, 1); if (!ok) return OPERATOR_CANCELLED; - len = BMO_GetSlot(&bmop, BM_CONVERTS_EDGEOUT)->len; + len = BMO_GetSlot(&bmop, "connectverts")->len; if (len) return; } @@ -703,7 +703,7 @@ static void addedgeface_mesh(EditMesh *em, wmOperator *op) ok = EDBM_Finish(bm, em, op, 1); if (!ok) return OPERATOR_CANCELLED; - len = BMO_GetSlot(&bmop, BMOP_DISFACES_REGIONOUT)->len; + len = BMO_GetSlot(&bmop, "regionout")->len; if (len) return; } diff --git a/source/blender/editors/mesh/editmesh_lib.c b/source/blender/editors/mesh/editmesh_lib.c index 2b299020fb8..ea6a5442072 100644 --- a/source/blender/editors/mesh/editmesh_lib.c +++ b/source/blender/editors/mesh/editmesh_lib.c @@ -1158,20 +1158,20 @@ short BM_extrude_edgeflag(Object *obedit, BMesh *bm, int eflag, float *nor) break; } - for (f=BMIter_New(&iter, bm, BM_FACES, NULL);f;f=BMIter_Step(&iter)) { + for (f=BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL);f;f=BMIter_Step(&iter)) { add_normal_aligned(nor, f->no); } Normalize(nor); - BMO_Init_Op(&extop, BMOP_EXTRUDE_EDGECONTEXT); - BMO_HeaderFlag_To_Slot(bm, &extop, BMOP_EXFACE_EDGEFACEIN, + BMO_Init_Op(&extop, "extrudefaceregion"); + BMO_HeaderFlag_To_Slot(bm, &extop, "edgefacein", flag, BM_VERT|BM_EDGE|BM_FACE); - for (edge=BMIter_New(&iter, bm, BM_EDGES, NULL); edge; edge=BMIter_Step(&iter)) { + for (edge=BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL); edge; edge=BMIter_Step(&iter)) { BM_Select_Edge(bm, edge, 0); } - for (f=BMIter_New(&iter, bm, BM_FACES, NULL); f; f=BMIter_Step(&iter)) { + for (f=BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL); f; f=BMIter_Step(&iter)) { BM_Select_Face(bm, f, 0); } @@ -1191,7 +1191,7 @@ short BM_extrude_edgeflag(Object *obedit, BMesh *bm, int eflag, float *nor) Mat4MulMat4(mtx, obedit->obmat, imtx); } - for (edge=BMIter_New(&iter,bm,BM_EDGES,NULL); + for (edge=BMIter_New(&iter,bm,BM_EDGES_OF_MESH,NULL); edge; edge=BMIter_Step(&iter)) { if(edge->head.flag & flag) { @@ -1208,17 +1208,17 @@ short BM_extrude_edgeflag(Object *obedit, BMesh *bm, int eflag, float *nor) if (mmd->flag & MOD_MIR_AXIS_X) if ( (fabs(co1[0]) < mmd->tolerance) && (fabs(co2[0]) < mmd->tolerance) ) - BMO_Insert_MapPointer(bm, &extop, BMOP_EXFACE_EXCLUDEMAP, edge, NULL); + BMO_Insert_MapPointer(bm, &extop, "exclude", edge, NULL); if (mmd->flag & MOD_MIR_AXIS_Y) if ( (fabs(co1[1]) < mmd->tolerance) && (fabs(co2[1]) < mmd->tolerance) ) - BMO_Insert_MapPointer(bm, &extop, BMOP_EXFACE_EXCLUDEMAP, edge, NULL); + BMO_Insert_MapPointer(bm, &extop, "exclude", edge, NULL); if (mmd->flag & MOD_MIR_AXIS_Z) if ( (fabs(co1[2]) < mmd->tolerance) && (fabs(co2[2]) < mmd->tolerance) ) - BMO_Insert_MapPointer(bm, &extop, BMOP_EXFACE_EXCLUDEMAP, edge, NULL); + BMO_Insert_MapPointer(bm, &extop, "exclude", edge, NULL); } } } @@ -1228,7 +1228,7 @@ short BM_extrude_edgeflag(Object *obedit, BMesh *bm, int eflag, float *nor) BMO_Exec_Op(bm, &extop); - el = BMO_IterNew(&siter, bm, &extop, BMOP_EXFACE_MULTOUT); + el = BMO_IterNew(&siter, bm, &extop, "geomout"); for (; el; el=BMO_IterStep(&siter)) { BM_Select(bm, el, 1); } diff --git a/source/blender/editors/mesh/editmesh_loop.c b/source/blender/editors/mesh/editmesh_loop.c index 5fd0a2b6988..7afa5e1bceb 100644 --- a/source/blender/editors/mesh/editmesh_loop.c +++ b/source/blender/editors/mesh/editmesh_loop.c @@ -816,7 +816,7 @@ static int knife_cut_exec(bContext *C, wmOperator *op) /*the floating point coordinates of verts in screen space will be stored in a hash table according to the vertices pointer*/ gh = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp); - for(bv=BMIter_New(&iter, bm, BM_VERTS, NULL);bv;bv=BMIter_Step(&iter)){ + for(bv=BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL);bv;bv=BMIter_Step(&iter)){ scr = MEM_mallocN(sizeof(float)*2, "Vertex Screen Coordinates"); VECCOPY(co, bv->co); co[3]= 1.0; @@ -825,18 +825,18 @@ static int knife_cut_exec(bContext *C, wmOperator *op) BLI_ghash_insert(gh, bv, scr); } - BMO_Init_Op(&bmop, BMOP_ESUBDIVIDE); + BMO_Init_Op(&bmop, "esubd"); i = 0; /*store percentage of edge cut for KNIFE_EXACT here.*/ - for (be=BMIter_New(&iter, bm, BM_EDGES, NULL); be; be=BMIter_Step(&iter)) { + for (be=BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL); be; be=BMIter_Step(&iter)) { if( BM_Is_Selected(bm, be) ) { isect= bm_seg_intersect(be, curve, len, mode, gh, &isected); if (isect != 0.0f) { if (mode != KNIFE_MULTICUT) { BMO_Insert_MapFloat(bm, &bmop, - BMOP_ESUBDIVIDE_PERCENT_EDGEMAP, + "edgepercents", be, isect); } @@ -845,13 +845,13 @@ static int knife_cut_exec(bContext *C, wmOperator *op) } } - BMO_Flag_To_Slot(bm, &bmop, BMOP_ESUBDIVIDE_EDGES, 1, BM_EDGE); + BMO_Flag_To_Slot(bm, &bmop, "edges", 1, BM_EDGE); - BMO_Set_Int(&bmop, BMOP_ESUBDIVIDE_NUMCUTS, numcuts); + BMO_Set_Int(&bmop, "numcuts", numcuts); flag = B_KNIFE; if (mode == KNIFE_MIDPOINT) numcuts = 1; - BMO_Set_Int(&bmop, BMOP_ESUBDIVIDE_FLAG, flag); - BMO_Set_Float(&bmop, BMOP_ESUBDIVIDE_RADIUS, 0); + BMO_Set_Int(&bmop, "flag", flag); + BMO_Set_Float(&bmop, "radius", 0); BMO_Exec_Op(bm, &bmop); BMO_Finish_Op(bm, &bmop); diff --git a/source/blender/editors/mesh/editmesh_mods.c b/source/blender/editors/mesh/editmesh_mods.c index 7ec0fceaf2c..a77f6cbc538 100644 --- a/source/blender/editors/mesh/editmesh_mods.c +++ b/source/blender/editors/mesh/editmesh_mods.c @@ -1792,7 +1792,7 @@ static void edgeloop_select(EditMesh *em, EditEdge *starteed, int select) bm = init_editmesh_to_bmesh(em, &op); BMO_Exec_Op(bm, &op); - e = BMO_Get_MapPointer(bm, &op, BMOP_FROM_EDITMESH_MAP, starteed); + e = BMO_Get_MapPointer(bm, &op, "map", starteed); BMW_Init(&walker, bm, BMW_LOOP, 0); e = BMW_Begin(&walker, e); @@ -3271,8 +3271,8 @@ static int bmesh_test_exec(bContext *C, wmOperator *op) BMOpSlot *eoutput, *foutput; int i; - BMO_Init_Op(&op, BMOP_DISSOLVE_VERTS); - BMO_HeaderFlag_To_Slot(bm, &op, BMOP_DISVERTS_VERTIN, BM_SELECT, BM_VERT); + BMO_Init_Op(&op, "dissolveverts"); + BMO_HeaderFlag_To_Slot(bm, &op, "verts", BM_SELECT, BM_VERT); BMO_Exec_Op(bm, &op); BMO_Finish_Op(bm, &op); @@ -3286,12 +3286,12 @@ static int bmesh_test_exec(bContext *C, wmOperator *op) BMOpSlot *eoutput, *foutput; int i; - BMO_Init_Op(&op, BMOP_TRIANGULATE); - BMO_HeaderFlag_To_Slot(bm, &op, BMOP_TRIANG_FACEIN, BM_SELECT, BM_FACE); + BMO_Init_Op(&op, "triangulate"); + BMO_HeaderFlag_To_Slot(bm, &op, "faces", BM_SELECT, BM_FACE); BMO_Exec_Op(bm, &op); - eoutput = BMO_GetSlot(&op, BMOP_TRIANG_NEW_EDGES); - foutput = BMO_GetSlot(&op, BMOP_TRIANG_NEW_FACES); + eoutput = BMO_GetSlot(&op, "edgeout"); + foutput = BMO_GetSlot(&op, "faceout"); /*select new faces/edges*/ for (i=0; ilen; i++) {