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

removed all those nasty enums from the operator api. yay! I'm

Browse Source 
so happy.  so now operators and their slots are referred to by
string names.  so much easier to remember!
This commit is contained in:
Joseph Eagar
2009-03-22 23:16:43 +00:00
parent 329a8e44ff
commit 52fc6d7829
25 changed files with 436 additions and 516 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -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

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

@@ -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.

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

@@ -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;

6
source/blender/bmesh/bmesh_queries.h
View File

@@ -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.*/

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

@@ -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;

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

@@ -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++;
}
}

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

@@ -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);

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

@@ -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);

47
source/blender/bmesh/intern/bmesh_opdefines.c
View File

@@ -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
};

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

@@ -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; i<opdefines[op->type]->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; i<def->totslot; 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; i<bmesh_total_ops; i++) {
if (!strcmp(opname, opdefines[i]->name)) 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);
}

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

@@ -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)
{

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

@@ -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;

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

@@ -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; i<eout->len; 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;

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

@@ -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;

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

@@ -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;
}

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

@@ -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);

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

@@ -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);

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

@@ -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);

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

@@ -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);

36
source/blender/bmesh/operators/subdivideop.c
View File

@@ -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; i<pat->len; i++) {
matched = 1;
for (j=0; j<pat->len; 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; i<einput->len; 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);
}

11
source/blender/bmesh/operators/triangulateop.c
View File

@@ -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);
}

4
source/blender/editors/mesh/editmesh_add.c
View File

@@ -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;
}

20
source/blender/editors/mesh/editmesh_lib.c
View File

@@ -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);
}

16
source/blender/editors/mesh/editmesh_loop.c
View File

@@ -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);

14
source/blender/editors/mesh/editmesh_mods.c
View File

@@ -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; i<eoutput->len; i++) {