Cr8-xyz/blender
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

code cleanup: rename some members of bmesh operators, 'slots' is a C++ keyword which confuses some IDE's.

Browse Source 
also added missing BMO_op_vinitf args to comments.
This commit is contained in:
Campbell Barton
2012-06-30 09:55:04 +00:00
parent 436f02ab9c
commit 35d8424273
4 changed files with 214 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

81
source/blender/bmesh/intern/bmesh_operator_api.h
View File

@@ -116,7 +116,7 @@ enum {
* for when your defining an operator with BMOpDefine.*/ * for when your defining an operator with BMOpDefine.*/
typedef struct BMOpSlot { typedef struct BMOpSlot {
int slottype; int slot_type;
int len; int len;
int flag; int flag;
int index; /* index within slot array */ int index; /* index within slot array */
@@ -132,16 +132,13 @@ typedef struct BMOpSlot {
#define BMO_OP_MAX_SLOTS 16 /* way more than probably needed */ #define BMO_OP_MAX_SLOTS 16 /* way more than probably needed */
#ifdef slots
#undef slots
#endif
typedef struct BMOperator { typedef struct BMOperator {
int type; int type;
int slottype; int slot_type;
int needflag; int needflag;
int flag; int flag;
struct BMOpSlot slots[BMO_OP_MAX_SLOTS]; void (*exec)(BMesh *bm, struct BMOperator *op); struct BMOpSlot slot_args[BMO_OP_MAX_SLOTS];
void (*exec)(BMesh *bm, struct BMOperator *op);
struct MemArena *arena; struct MemArena *arena;
} BMOperator; } BMOperator;
@@ -154,7 +151,7 @@ typedef struct BMOSlotType {
typedef struct BMOpDefine { typedef struct BMOpDefine {
const char *name; const char *name;
BMOSlotType slottypes[BMO_OP_MAX_SLOTS]; BMOSlotType slot_types[BMO_OP_MAX_SLOTS];
void (*exec)(BMesh *bm, BMOperator *op); void (*exec)(BMesh *bm, BMOperator *op);
int flag; int flag;
} BMOpDefine; } BMOpDefine;
@@ -201,7 +198,7 @@ int BMO_mesh_disabled_flag_count(BMesh *bm, const char htype, const short oflag)
* . . .will execute the delete operator, feeding in selected faces, deleting them. * . . .will execute the delete operator, feeding in selected faces, deleting them.
* *
* the basic format for the format string is: * the basic format for the format string is:
* [operatorname] [slotname]=%[code] [slotname]=%[code] * [operatorname] [slot_name]=%[code] [slot_name]=%[code]
* *
* as in printf, you pass in one additional argument to the function * as in printf, you pass in one additional argument to the function
* for every code. * for every code.
@@ -246,10 +243,10 @@ int BMO_op_initf(BMesh *bm, BMOperator *op, const char *fmt, ...);
int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *fmt, va_list vlist); int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *fmt, va_list vlist);
/* test whether a named slot exists */ /* test whether a named slot exists */
int BMO_slot_exists(BMOperator *op, const char *slotname); int BMO_slot_exists(BMOperator *op, const char *slot_name);
/* get a pointer to a slot. this may be removed layer on from the public API. */ /* get a pointer to a slot. this may be removed layer on from the public API. */
BMOpSlot *BMO_slot_get(BMOperator *op, const char *slotname); BMOpSlot *BMO_slot_get(BMOperator *op, const char *slot_name);
/* copies the data of a slot from one operator to another. src and dst are the /* copies the data of a slot from one operator to another. src and dst are the
* source/destination slot codes, respectively. */ * source/destination slot codes, respectively. */
@@ -270,30 +267,30 @@ enum {
void BMO_op_flag_enable(BMesh *bm, BMOperator *op, const int op_flag); void BMO_op_flag_enable(BMesh *bm, BMOperator *op, const int op_flag);
void BMO_op_flag_disable(BMesh *bm, BMOperator *op, const int op_flag); void BMO_op_flag_disable(BMesh *bm, BMOperator *op, const int op_flag);
void BMO_slot_float_set(BMOperator *op, const char *slotname, const float f); void BMO_slot_float_set(BMOperator *op, const char *slot_name, const float f);
float BMO_slot_float_get(BMOperator *op, const char *slotname); float BMO_slot_float_get(BMOperator *op, const char *slot_name);
void BMO_slot_int_set(BMOperator *op, const char *slotname, const int i); void BMO_slot_int_set(BMOperator *op, const char *slot_name, const int i);
int BMO_slot_int_get(BMOperator *op, const char *slotname); int BMO_slot_int_get(BMOperator *op, const char *slot_name);
void BMO_slot_bool_set(BMOperator *op, const char *slotname, const int i); void BMO_slot_bool_set(BMOperator *op, const char *slot_name, const int i);
int BMO_slot_bool_get(BMOperator *op, const char *slotname); int BMO_slot_bool_get(BMOperator *op, const char *slot_name);
/* don't pass in arrays that are supposed to map to elements this way. /* 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. * 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 * passing in, e.g. pointer to an editmesh for the conversion operator is fine
* though. */ * though. */
void BMO_slot_ptr_set(BMOperator *op, const char *slotname, void *p); void BMO_slot_ptr_set(BMOperator *op, const char *slot_name, void *p);
void *BMO_slot_ptr_get(BMOperator *op, const char *slotname); void *BMO_slot_ptr_get(BMOperator *op, const char *slot_name);
void BMO_slot_vec_set(BMOperator *op, const char *slotname, const float vec[3]); void BMO_slot_vec_set(BMOperator *op, const char *slot_name, const float vec[3]);
void BMO_slot_vec_get(BMOperator *op, const char *slotname, float r_vec[3]); void BMO_slot_vec_get(BMOperator *op, const char *slot_name, float r_vec[3]);
/* only supports square mats */ /* only supports square mats */
/* size must be 3 or 4; this api is meant only for transformation matrices. /* size must be 3 or 4; this api is meant only for transformation matrices.
* note that internally the matrix is stored in 4x4 form, and it's safe to * note that internally the matrix is stored in 4x4 form, and it's safe to
* call whichever BMO_Get_Mat* function you want. */ * call whichever BMO_Get_Mat* function you want. */
void BMO_slot_mat_set(BMOperator *op, const char *slotname, const float *mat, int size); void BMO_slot_mat_set(BMOperator *op, const char *slot_name, const float *mat, int size);
void BMO_slot_mat4_get(BMOperator *op, const char *slotname, float r_mat[4][4]); void BMO_slot_mat4_get(BMOperator *op, const char *slot_name, float r_mat[4][4]);
void BMO_slot_mat3_set(BMOperator *op, const char *slotname, float r_mat[3][3]); void BMO_slot_mat3_set(BMOperator *op, const char *slot_name, float r_mat[3][3]);
void BMO_mesh_flag_disable_all(BMesh *bm, BMOperator *op, const char htype, const short oflag); void BMO_mesh_flag_disable_all(BMesh *bm, BMOperator *op, const char htype, const short oflag);
@@ -303,47 +300,47 @@ void BMO_slot_buffer_append(BMOperator *output_op, const char *output_op_slot,
/* puts every element of type 'type' (which is a bitmask) with tool /* puts every element of type 'type' (which is a bitmask) with tool
* flag 'flag', into a slot. */ * flag 'flag', into a slot. */
void BMO_slot_buffer_from_enabled_flag(BMesh *bm, BMOperator *op, const char *slotname, void BMO_slot_buffer_from_enabled_flag(BMesh *bm, BMOperator *op, const char *slot_name,
const char htype, const short oflag); const char htype, const short oflag);
/* puts every element of type 'type' (which is a bitmask) without tool /* puts every element of type 'type' (which is a bitmask) without tool
* flag 'flag', into a slot. */ * flag 'flag', into a slot. */
void BMO_slot_buffer_from_disabled_flag(BMesh *bm, BMOperator *op, const char *slotname, void BMO_slot_buffer_from_disabled_flag(BMesh *bm, BMOperator *op, const char *slot_name,
const char htype, const short oflag); const char htype, const short oflag);
/* tool-flags all elements inside an element slot array with flag flag. */ /* tool-flags all elements inside an element slot array with flag flag. */
void BMO_slot_buffer_flag_enable(BMesh *bm, BMOperator *op, const char *slotname, void BMO_slot_buffer_flag_enable(BMesh *bm, BMOperator *op, const char *slot_name,
const char htype, const short oflag); const char htype, const short oflag);
/* clears tool-flag flag from all elements inside a slot array. */ /* clears tool-flag flag from all elements inside a slot array. */
void BMO_slot_buffer_flag_disable(BMesh *bm, BMOperator *op, const char *slotname, void BMO_slot_buffer_flag_disable(BMesh *bm, BMOperator *op, const char *slot_name,
const char htype, const short oflag); const char htype, const short oflag);
/* tool-flags all elements inside an element slot array with flag flag. */ /* tool-flags all elements inside an element slot array with flag flag. */
void BMO_slot_buffer_hflag_enable(BMesh *bm, BMOperator *op, const char *slotname, void BMO_slot_buffer_hflag_enable(BMesh *bm, BMOperator *op, const char *slot_name,
const char htype, const char hflag, const char do_flush); const char htype, const char hflag, const char do_flush);
/* clears tool-flag flag from all elements inside a slot array. */ /* clears tool-flag flag from all elements inside a slot array. */
void BMO_slot_buffer_hflag_disable(BMesh *bm, BMOperator *op, const char *slotname, void BMO_slot_buffer_hflag_disable(BMesh *bm, BMOperator *op, const char *slot_name,
const char htype, const char hflag, const char do_flush); const char htype, const char hflag, const char do_flush);
/* puts every element of type 'type' (which is a bitmask) with header /* puts every element of type 'type' (which is a bitmask) with header
* flag 'flag', into a slot. note: ignores hidden elements * flag 'flag', into a slot. note: ignores hidden elements
* (e.g. elements with header flag BM_ELEM_HIDDEN set).*/ * (e.g. elements with header flag BM_ELEM_HIDDEN set).*/
void BMO_slot_buffer_from_enabled_hflag(BMesh *bm, BMOperator *op, void BMO_slot_buffer_from_enabled_hflag(BMesh *bm, BMOperator *op,
const char *slotname, const char *slot_name,
const char htype, const char hflag); const char htype, const char hflag);
/* puts every element of type 'type' (which is a bitmask) without /* puts every element of type 'type' (which is a bitmask) without
* header flag 'flag', into a slot. note: ignores hidden elements * header flag 'flag', into a slot. note: ignores hidden elements
* (e.g. elements with header flag BM_ELEM_HIDDEN set).*/ * (e.g. elements with header flag BM_ELEM_HIDDEN set).*/
void BMO_slot_buffer_from_disabled_hflag(BMesh *bm, BMOperator *op, void BMO_slot_buffer_from_disabled_hflag(BMesh *bm, BMOperator *op,
const char *slotname, const char *slot_name,
const char htype, const char hflag); const char htype, const char hflag);
/* counts number of elements inside a slot array. */ /* counts number of elements inside a slot array. */
int BMO_slot_buffer_count(BMesh *bm, BMOperator *op, const char *slotname); int BMO_slot_buffer_count(BMesh *bm, BMOperator *op, const char *slot_name);
int BMO_slot_map_count(BMesh *bm, BMOperator *op, const char *slotname); int BMO_slot_map_count(BMesh *bm, BMOperator *op, const char *slot_name);
void BMO_slot_map_insert(BMesh *UNUSED(bm), BMOperator *op, const char *slotname, void BMO_slot_map_insert(BMesh *UNUSED(bm), BMOperator *op, const char *slot_name,
void *element, void *data, int len); void *element, void *data, int len);
/* Counts the number of edges with tool flag toolflag around /* Counts the number of edges with tool flag toolflag around
@@ -352,7 +349,7 @@ int BMO_vert_edge_flags_count(BMesh *bm, BMVert *v, const short oflag);
/* flags all elements in a mapping. note that the mapping must only have /* flags all elements in a mapping. note that the mapping must only have
* bmesh elements in it.*/ * bmesh elements in it.*/
void BMO_slot_map_to_flag(BMesh *bm, BMOperator *op, const char *slotname, void BMO_slot_map_to_flag(BMesh *bm, BMOperator *op, const char *slot_name,
const char hflag, const short oflag); const char hflag, const short oflag);
/* this part of the API is used to iterate over element buffer or /* this part of the API is used to iterate over element buffer or
@@ -363,7 +360,7 @@ void BMO_slot_map_to_flag(BMesh *bm, BMOperator *op, const char *slotname,
* BMOIter oiter; * BMOIter oiter;
* BMFace *f; * BMFace *f;
* *
* f = BMO_iter_new(&oiter, bm, some_operator, "slotname", BM_FACE); * f = BMO_iter_new(&oiter, bm, some_operator, "slot_name", BM_FACE);
* for (; f; f = BMO_iter_step(&oiter)) { * for (; f; f = BMO_iter_step(&oiter)) {
* /do something with the face * /do something with the face
* } * }
@@ -373,7 +370,7 @@ void BMO_slot_map_to_flag(BMesh *bm, BMOperator *op, const char *slotname,
* void *key; * void *key;
* void *val; * void *val;
* *
* key = BMO_iter_new(&oiter, bm, some_operator, "slotname", 0); * key = BMO_iter_new(&oiter, bm, some_operator, "slot_name", 0);
* for (; key; key = BMO_iter_step(&oiter)) { * for (; key; key = BMO_iter_step(&oiter)) {
* val = BMO_iter_map_value(&oiter); * val = BMO_iter_map_value(&oiter);
* //do something with the key/val pair * //do something with the key/val pair
@@ -396,10 +393,10 @@ typedef struct BMOIter {
char restrictmask; /* bitwise '&' with BMHeader.htype */ char restrictmask; /* bitwise '&' with BMHeader.htype */
} BMOIter; } BMOIter;
void *BMO_slot_buffer_elem_first(BMOperator *op, const char *slotname); void *BMO_slot_buffer_elem_first(BMOperator *op, const char *slot_name);
void *BMO_iter_new(BMOIter *iter, BMesh *bm, BMOperator *op, void *BMO_iter_new(BMOIter *iter, BMesh *bm, BMOperator *op,
const char *slotname, const char restrictmask); const char *slot_name, const char restrictmask);
void *BMO_iter_step(BMOIter *iter); void *BMO_iter_step(BMOIter *iter);
/* returns a pointer to the key value when iterating over mappings. /* returns a pointer to the key value when iterating over mappings.
@@ -412,8 +409,8 @@ void *BMO_iter_map_value_p(BMOIter *iter);
/* use this for float mappings */ /* use this for float mappings */
float BMO_iter_map_value_f(BMOIter *iter); float BMO_iter_map_value_f(BMOIter *iter);
#define BMO_ITER(ele, iter, bm, op, slotname, restrict) \ #define BMO_ITER(ele, iter, bm, op, slot_name, restrict) \
for (ele = BMO_iter_new(iter, bm, op, slotname, restrict); ele; ele = BMO_iter_step(iter)) for (ele = BMO_iter_new(iter, bm, op, slot_name, restrict); ele; ele = BMO_iter_step(iter))
/******************* Inlined Functions********************/ /******************* Inlined Functions********************/
typedef void (*opexec)(BMesh *bm, BMOperator *op); typedef void (*opexec)(BMesh *bm, BMOperator *op);

36
source/blender/bmesh/intern/bmesh_operator_api_inline.h
View File

@@ -69,16 +69,16 @@ BLI_INLINE void _bmo_elem_flag_toggle(BMesh *bm, BMFlagLayer *oflags, const shor
oflags[bm->stackdepth - 1].f ^= oflag; oflags[bm->stackdepth - 1].f ^= oflag;
} }
BLI_INLINE void BMO_slot_map_int_insert(BMesh *bm, BMOperator *op, const char *slotname, BLI_INLINE void BMO_slot_map_int_insert(BMesh *bm, BMOperator *op, const char *slot_name,
void *element, int val) void *element, int val)
{ {
BMO_slot_map_insert(bm, op, slotname, element, &val, sizeof(int)); BMO_slot_map_insert(bm, op, slot_name, element, &val, sizeof(int));
} }
BLI_INLINE void BMO_slot_map_float_insert(BMesh *bm, BMOperator *op, const char *slotname, BLI_INLINE void BMO_slot_map_float_insert(BMesh *bm, BMOperator *op, const char *slot_name,
void *element, float val) void *element, float val)
{ {
BMO_slot_map_insert(bm, op, slotname, element, &val, sizeof(float)); BMO_slot_map_insert(bm, op, slot_name, element, &val, sizeof(float));
} }
@@ -87,16 +87,16 @@ BLI_INLINE void BMO_slot_map_float_insert(BMesh *bm, BMOperator *op, const char
* do NOT use these for non-operator-api-allocated memory! instead * do NOT use these for non-operator-api-allocated memory! instead
* use BMO_slot_map_data_get and BMO_slot_map_insert, which copies the data. */ * use BMO_slot_map_data_get and BMO_slot_map_insert, which copies the data. */
BLI_INLINE void BMO_slot_map_ptr_insert(BMesh *bm, BMOperator *op, const char *slotname, BLI_INLINE void BMO_slot_map_ptr_insert(BMesh *bm, BMOperator *op, const char *slot_name,
void *element, void *val) void *element, void *val)
{ {
BMO_slot_map_insert(bm, op, slotname, element, &val, sizeof(void *)); BMO_slot_map_insert(bm, op, slot_name, element, &val, sizeof(void *));
} }
BLI_INLINE int BMO_slot_map_contains(BMesh *UNUSED(bm), BMOperator *op, const char *slotname, void *element) BLI_INLINE int BMO_slot_map_contains(BMesh *UNUSED(bm), BMOperator *op, const char *slot_name, void *element)
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BLI_assert(slot->slottype == BMO_OP_SLOT_MAPPING); BLI_assert(slot->slot_type == BMO_OP_SLOT_MAPPING);
/* sanity check */ /* sanity check */
if (!slot->data.ghash) return 0; if (!slot->data.ghash) return 0;
@@ -104,12 +104,12 @@ BLI_INLINE int BMO_slot_map_contains(BMesh *UNUSED(bm), BMOperator *op, const ch
return BLI_ghash_haskey(slot->data.ghash, element); return BLI_ghash_haskey(slot->data.ghash, element);
} }
BLI_INLINE void *BMO_slot_map_data_get(BMesh *UNUSED(bm), BMOperator *op, const char *slotname, BLI_INLINE void *BMO_slot_map_data_get(BMesh *UNUSED(bm), BMOperator *op, const char *slot_name,
void *element) void *element)
{ {
BMOElemMapping *mapping; BMOElemMapping *mapping;
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BLI_assert(slot->slottype == BMO_OP_SLOT_MAPPING); BLI_assert(slot->slot_type == BMO_OP_SLOT_MAPPING);
/* sanity check */ /* sanity check */
if (!slot->data.ghash) return NULL; if (!slot->data.ghash) return NULL;
@@ -121,28 +121,28 @@ BLI_INLINE void *BMO_slot_map_data_get(BMesh *UNUSED(bm), BMOperator *op, const
return mapping + 1; return mapping + 1;
} }
BLI_INLINE float BMO_slot_map_float_get(BMesh *bm, BMOperator *op, const char *slotname, BLI_INLINE float BMO_slot_map_float_get(BMesh *bm, BMOperator *op, const char *slot_name,
void *element) void *element)
{ {
float *val = (float *) BMO_slot_map_data_get(bm, op, slotname, element); float *val = (float *) BMO_slot_map_data_get(bm, op, slot_name, element);
if (val) return *val; if (val) return *val;
return 0.0f; return 0.0f;
} }
BLI_INLINE int BMO_slot_map_int_get(BMesh *bm, BMOperator *op, const char *slotname, BLI_INLINE int BMO_slot_map_int_get(BMesh *bm, BMOperator *op, const char *slot_name,
void *element) void *element)
{ {
int *val = (int *) BMO_slot_map_data_get(bm, op, slotname, element); int *val = (int *) BMO_slot_map_data_get(bm, op, slot_name, element);
if (val) return *val; if (val) return *val;
return 0; return 0;
} }
BLI_INLINE void *BMO_slot_map_ptr_get(BMesh *bm, BMOperator *op, const char *slotname, BLI_INLINE void *BMO_slot_map_ptr_get(BMesh *bm, BMOperator *op, const char *slot_name,
void *element) void *element)
{ {
void **val = (void **) BMO_slot_map_data_get(bm, op, slotname, element); void **val = (void **) BMO_slot_map_data_get(bm, op, slot_name, element);
if (val) return *val; if (val) return *val;
return NULL; return NULL;

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

@@ -145,9 +145,9 @@ void BMO_op_init(BMesh *bm, BMOperator *op, const char *opname)
op->flag = opdefines[opcode]->flag; op->flag = opdefines[opcode]->flag;
/* initialize the operator slot types */ /* initialize the operator slot types */
for (i = 0; opdefines[opcode]->slottypes[i].type; i++) { for (i = 0; opdefines[opcode]->slot_types[i].type; i++) {
op->slots[i].slottype = opdefines[opcode]->slottypes[i].type; op->slot_args[i].slot_type = opdefines[opcode]->slot_types[i].type;
op->slots[i].index = i; op->slot_args[i].index = i;
} }
/* callback */ /* callback */
@@ -192,9 +192,9 @@ void BMO_op_finish(BMesh *bm, BMOperator *op)
BMOpSlot *slot; BMOpSlot *slot;
int i; int i;
for (i = 0; opdefines[op->type]->slottypes[i].type; i++) { for (i = 0; opdefines[op->type]->slot_types[i].type; i++) {
slot = &op->slots[i]; slot = &op->slot_args[i];
if (slot->slottype == BMO_OP_SLOT_MAPPING) { if (slot->slot_type == BMO_OP_SLOT_MAPPING) {
if (slot->data.ghash) if (slot->data.ghash)
BLI_ghash_free(slot->data.ghash, NULL, NULL); BLI_ghash_free(slot->data.ghash, NULL, NULL);
} }
@@ -214,26 +214,26 @@ void BMO_op_finish(BMesh *bm, BMOperator *op)
* *
* \return Success if the slot if found. * \return Success if the slot if found.
*/ */
int BMO_slot_exists(BMOperator *op, const char *slotname) int BMO_slot_exists(BMOperator *op, const char *slot_name)
{ {
int slotcode = bmo_name_to_slotcode(opdefines[op->type], slotname); int slot_code = bmo_name_to_slotcode(opdefines[op->type], slot_name);
return (slotcode >= 0); return (slot_code >= 0);
} }
/** /**
* \brief BMESH OPSTACK GET SLOT * \brief BMESH OPSTACK GET SLOT
* *
* Returns a pointer to the slot of type 'slotcode' * Returns a pointer to the slot of type 'slot_code'
*/ */
BMOpSlot *BMO_slot_get(BMOperator *op, const char *slotname) BMOpSlot *BMO_slot_get(BMOperator *op, const char *slot_namee)
{ {
int slotcode = bmo_name_to_slotcode_check(opdefines[op->type], slotname); int slot_code = bmo_name_to_slotcode_check(opdefines[op->type], slot_namee);
if (slotcode < 0) { if (slot_code < 0) {
return &BMOpEmptySlot; return &BMOpEmptySlot;
} }
return &(op->slots[slotcode]); return &(op->slot_args[slot_code]);
} }
/** /**
@@ -249,22 +249,22 @@ void BMO_slot_copy(BMOperator *source_op, BMOperator *dest_op, const char *src,
if (source_slot == dest_slot) if (source_slot == dest_slot)
return; return;
if (source_slot->slottype != dest_slot->slottype) { if (source_slot->slot_type != dest_slot->slot_type) {
/* possibly assert here? */ /* possibly assert here? */
return; return;
} }
if (dest_slot->slottype == BMO_OP_SLOT_ELEMENT_BUF) { if (dest_slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF) {
/* do buffer copy */ /* do buffer copy */
dest_slot->data.buf = NULL; dest_slot->data.buf = NULL;
dest_slot->len = source_slot->len; dest_slot->len = source_slot->len;
if (dest_slot->len) { if (dest_slot->len) {
const int slot_alloc_size = BMO_OPSLOT_TYPEINFO[dest_slot->slottype] * dest_slot->len; const int slot_alloc_size = BMO_OPSLOT_TYPEINFO[dest_slot->slot_type] * dest_slot->len;
dest_slot->data.buf = BLI_memarena_alloc(dest_op->arena, slot_alloc_size); dest_slot->data.buf = BLI_memarena_alloc(dest_op->arena, slot_alloc_size);
memcpy(dest_slot->data.buf, source_slot->data.buf, slot_alloc_size); memcpy(dest_slot->data.buf, source_slot->data.buf, slot_alloc_size);
} }
} }
else if (dest_slot->slottype == BMO_OP_SLOT_MAPPING) { else if (dest_slot->slot_type == BMO_OP_SLOT_MAPPING) {
GHashIterator it; GHashIterator it;
BMOElemMapping *srcmap, *dstmap; BMOElemMapping *srcmap, *dstmap;
@@ -301,42 +301,42 @@ void BMO_slot_copy(BMOperator *source_op, BMOperator *dest_op, const char *src,
* Sets the value of a slot depending on it's type * Sets the value of a slot depending on it's type
*/ */
void BMO_slot_float_set(BMOperator *op, const char *slotname, const float f) void BMO_slot_float_set(BMOperator *op, const char *slot_name, const float f)
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BLI_assert(slot->slottype == BMO_OP_SLOT_FLT); BLI_assert(slot->slot_type == BMO_OP_SLOT_FLT);
if (!(slot->slottype == BMO_OP_SLOT_FLT)) if (!(slot->slot_type == BMO_OP_SLOT_FLT))
return; return;
slot->data.f = f; slot->data.f = f;
} }
void BMO_slot_int_set(BMOperator *op, const char *slotname, const int i) void BMO_slot_int_set(BMOperator *op, const char *slot_name, const int i)
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BLI_assert(slot->slottype == BMO_OP_SLOT_INT); BLI_assert(slot->slot_type == BMO_OP_SLOT_INT);
if (!(slot->slottype == BMO_OP_SLOT_INT)) if (!(slot->slot_type == BMO_OP_SLOT_INT))
return; return;
slot->data.i = i; slot->data.i = i;
} }
void BMO_slot_bool_set(BMOperator *op, const char *slotname, const int i) void BMO_slot_bool_set(BMOperator *op, const char *slot_name, const int i)
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BLI_assert(slot->slottype == BMO_OP_SLOT_BOOL); BLI_assert(slot->slot_type == BMO_OP_SLOT_BOOL);
if (!(slot->slottype == BMO_OP_SLOT_BOOL)) if (!(slot->slot_type == BMO_OP_SLOT_BOOL))
return; return;
slot->data.i = i; slot->data.i = i;
} }
/* only supports square mats */ /* only supports square mats */
void BMO_slot_mat_set(BMOperator *op, const char *slotname, const float *mat, int size) void BMO_slot_mat_set(BMOperator *op, const char *slot_name, const float *mat, int size)
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BLI_assert(slot->slottype == BMO_OP_SLOT_MAT); BLI_assert(slot->slot_type == BMO_OP_SLOT_MAT);
if (!(slot->slottype == BMO_OP_SLOT_MAT)) if (!(slot->slot_type == BMO_OP_SLOT_MAT))
return; return;
slot->len = 4; slot->len = 4;
@@ -355,93 +355,93 @@ void BMO_slot_mat_set(BMOperator *op, const char *slotname, const float *mat, in
} }
} }
void BMO_slot_mat4_get(BMOperator *op, const char *slotname, float r_mat[4][4]) void BMO_slot_mat4_get(BMOperator *op, const char *slot_name, float r_mat[4][4])
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BLI_assert(slot->slottype == BMO_OP_SLOT_MAT); BLI_assert(slot->slot_type == BMO_OP_SLOT_MAT);
if (!(slot->slottype == BMO_OP_SLOT_MAT)) if (!(slot->slot_type == BMO_OP_SLOT_MAT))
return; return;
copy_m4_m4(r_mat, (float (*)[4])slot->data.p); copy_m4_m4(r_mat, (float (*)[4])slot->data.p);
} }
void BMO_slot_mat3_set(BMOperator *op, const char *slotname, float r_mat[3][3]) void BMO_slot_mat3_set(BMOperator *op, const char *slot_name, float r_mat[3][3])
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BLI_assert(slot->slottype == BMO_OP_SLOT_MAT); BLI_assert(slot->slot_type == BMO_OP_SLOT_MAT);
if (!(slot->slottype == BMO_OP_SLOT_MAT)) if (!(slot->slot_type == BMO_OP_SLOT_MAT))
return; return;
copy_m3_m4(r_mat, slot->data.p); copy_m3_m4(r_mat, slot->data.p);
} }
void BMO_slot_ptr_set(BMOperator *op, const char *slotname, void *p) void BMO_slot_ptr_set(BMOperator *op, const char *slot_name, void *p)
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BLI_assert(slot->slottype == BMO_OP_SLOT_PNT); BLI_assert(slot->slot_type == BMO_OP_SLOT_PNT);
if (!(slot->slottype == BMO_OP_SLOT_PNT)) if (!(slot->slot_type == BMO_OP_SLOT_PNT))
return; return;
slot->data.p = p; slot->data.p = p;
} }
void BMO_slot_vec_set(BMOperator *op, const char *slotname, const float vec[3]) void BMO_slot_vec_set(BMOperator *op, const char *slot_name, const float vec[3])
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BLI_assert(slot->slottype == BMO_OP_SLOT_VEC); BLI_assert(slot->slot_type == BMO_OP_SLOT_VEC);
if (!(slot->slottype == BMO_OP_SLOT_VEC)) if (!(slot->slot_type == BMO_OP_SLOT_VEC))
return; return;
copy_v3_v3(slot->data.vec, vec); copy_v3_v3(slot->data.vec, vec);
} }
float BMO_slot_float_get(BMOperator *op, const char *slotname) float BMO_slot_float_get(BMOperator *op, const char *slot_name)
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BLI_assert(slot->slottype == BMO_OP_SLOT_FLT); BLI_assert(slot->slot_type == BMO_OP_SLOT_FLT);
if (!(slot->slottype == BMO_OP_SLOT_FLT)) if (!(slot->slot_type == BMO_OP_SLOT_FLT))
return 0.0f; return 0.0f;
return slot->data.f; return slot->data.f;
} }
int BMO_slot_int_get(BMOperator *op, const char *slotname) int BMO_slot_int_get(BMOperator *op, const char *slot_name)
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BLI_assert(slot->slottype == BMO_OP_SLOT_INT); BLI_assert(slot->slot_type == BMO_OP_SLOT_INT);
if (!(slot->slottype == BMO_OP_SLOT_INT)) if (!(slot->slot_type == BMO_OP_SLOT_INT))
return 0; return 0;
return slot->data.i; return slot->data.i;
} }
int BMO_slot_bool_get(BMOperator *op, const char *slotname) int BMO_slot_bool_get(BMOperator *op, const char *slot_name)
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BLI_assert(slot->slottype == BMO_OP_SLOT_BOOL); BLI_assert(slot->slot_type == BMO_OP_SLOT_BOOL);
if (!(slot->slottype == BMO_OP_SLOT_BOOL)) if (!(slot->slot_type == BMO_OP_SLOT_BOOL))
return 0; return 0;
return slot->data.i; return slot->data.i;
} }
void *BMO_slot_ptr_get(BMOperator *op, const char *slotname) void *BMO_slot_ptr_get(BMOperator *op, const char *slot_name)
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BLI_assert(slot->slottype == BMO_OP_SLOT_PNT); BLI_assert(slot->slot_type == BMO_OP_SLOT_PNT);
if (!(slot->slottype == BMO_OP_SLOT_PNT)) if (!(slot->slot_type == BMO_OP_SLOT_PNT))
return NULL; return NULL;
return slot->data.p; return slot->data.p;
} }
void BMO_slot_vec_get(BMOperator *op, const char *slotname, float r_vec[3]) void BMO_slot_vec_get(BMOperator *op, const char *slot_name, float r_vec[3])
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BLI_assert(slot->slottype == BMO_OP_SLOT_VEC); BLI_assert(slot->slot_type == BMO_OP_SLOT_VEC);
if (!(slot->slottype == BMO_OP_SLOT_VEC)) if (!(slot->slot_type == BMO_OP_SLOT_VEC))
return; return;
copy_v3_v3(r_vec, slot->data.vec); copy_v3_v3(r_vec, slot->data.vec);
@@ -515,25 +515,25 @@ void BMO_mesh_flag_disable_all(BMesh *bm, BMOperator *UNUSED(op), const char hty
} }
} }
int BMO_slot_buffer_count(BMesh *UNUSED(bm), BMOperator *op, const char *slotname) int BMO_slot_buffer_count(BMesh *UNUSED(bm), BMOperator *op, const char *slot_name)
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF); BLI_assert(slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF);
/* check if its actually a buffer */ /* check if its actually a buffer */
if (slot->slottype != BMO_OP_SLOT_ELEMENT_BUF) if (slot->slot_type != BMO_OP_SLOT_ELEMENT_BUF)
return 0; return 0;
return slot->len; return slot->len;
} }
int BMO_slot_map_count(BMesh *UNUSED(bm), BMOperator *op, const char *slotname) int BMO_slot_map_count(BMesh *UNUSED(bm), BMOperator *op, const char *slot_name)
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BLI_assert(slot->slottype == BMO_OP_SLOT_MAPPING); BLI_assert(slot->slot_type == BMO_OP_SLOT_MAPPING);
/* check if its actually a buffer */ /* check if its actually a buffer */
if (!(slot->slottype == BMO_OP_SLOT_MAPPING)) if (!(slot->slot_type == BMO_OP_SLOT_MAPPING))
return 0; return 0;
return slot->data.ghash ? BLI_ghash_size(slot->data.ghash) : 0; return slot->data.ghash ? BLI_ghash_size(slot->data.ghash) : 0;
@@ -542,12 +542,12 @@ int BMO_slot_map_count(BMesh *UNUSED(bm), BMOperator *op, const char *slotname)
/* inserts a key/value mapping into a mapping slot. note that it copies the /* inserts a key/value mapping into a mapping slot. note that it copies the
* value, it doesn't store a reference to it. */ * value, it doesn't store a reference to it. */
void BMO_slot_map_insert(BMesh *UNUSED(bm), BMOperator *op, const char *slotname, void BMO_slot_map_insert(BMesh *UNUSED(bm), BMOperator *op, const char *slot_name,
void *element, void *data, int len) void *element, void *data, int len)
{ {
BMOElemMapping *mapping; BMOElemMapping *mapping;
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BLI_assert(slot->slottype == BMO_OP_SLOT_MAPPING); BLI_assert(slot->slot_type == BMO_OP_SLOT_MAPPING);
mapping = (BMOElemMapping *) BLI_memarena_alloc(op->arena, sizeof(*mapping) + len); mapping = (BMOElemMapping *) BLI_memarena_alloc(op->arena, sizeof(*mapping) + len);
@@ -563,9 +563,9 @@ void BMO_slot_map_insert(BMesh *UNUSED(bm), BMOperator *op, const char *slotname
} }
#if 0 #if 0
void *bmo_slot_buffer_grow(BMesh *bm, BMOperator *op, int slotcode, int totadd) void *bmo_slot_buffer_grow(BMesh *bm, BMOperator *op, int slot_code, int totadd)
{ {
BMOpSlot *slot = &op->slots[slotcode]; BMOpSlot *slot = &op->slots[slot_code];
void *tmp; void *tmp;
ssize_t allocsize; ssize_t allocsize;
@@ -579,7 +579,7 @@ void *bmo_slot_buffer_grow(BMesh *bm, BMOperator *op, int slotcode, int totadd)
if (slot->len >= slot->size) { if (slot->len >= slot->size) {
slot->size = (slot->size + 1 + totadd) * 2; slot->size = (slot->size + 1 + totadd) * 2;
allocsize = BMO_OPSLOT_TYPEINFO[opdefines[op->type]->slottypes[slotcode].type] * slot->size; allocsize = BMO_OPSLOT_TYPEINFO[opdefines[op->type]->slot_types[slot_code].type] * slot->size;
tmp = slot->data.buf; tmp = slot->data.buf;
slot->data.buf = MEM_callocN(allocsize, "opslot dynamic array"); slot->data.buf = MEM_callocN(allocsize, "opslot dynamic array");
@@ -594,7 +594,7 @@ void *bmo_slot_buffer_grow(BMesh *bm, BMOperator *op, int slotcode, int totadd)
slot->len += totadd; slot->len += totadd;
slot->size = slot->len + 2; slot->size = slot->len + 2;
allocsize = BMO_OPSLOT_TYPEINFO[opdefines[op->type]->slottypes[slotcode].type] * slot->len; allocsize = BMO_OPSLOT_TYPEINFO[opdefines[op->type]->slot_types[slot_code].type] * slot->len;
tmp = slot->data.buf; tmp = slot->data.buf;
slot->data.buf = MEM_callocN(allocsize, "opslot dynamic array"); slot->data.buf = MEM_callocN(allocsize, "opslot dynamic array");
@@ -605,14 +605,14 @@ void *bmo_slot_buffer_grow(BMesh *bm, BMOperator *op, int slotcode, int totadd)
} }
#endif #endif
void BMO_slot_map_to_flag(BMesh *bm, BMOperator *op, const char *slotname, void BMO_slot_map_to_flag(BMesh *bm, BMOperator *op, const char *slot_name,
const char htype, const short oflag) const char htype, const short oflag)
{ {
GHashIterator it; GHashIterator it;
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BMElemF *ele_f; BMElemF *ele_f;
BLI_assert(slot->slottype == BMO_OP_SLOT_MAPPING); BLI_assert(slot->slot_type == BMO_OP_SLOT_MAPPING);
/* sanity check */ /* sanity check */
if (!slot->data.ghash) return; if (!slot->data.ghash) return;
@@ -625,18 +625,18 @@ void BMO_slot_map_to_flag(BMesh *bm, BMOperator *op, const char *slotname,
} }
} }
static void *bmo_slot_buffer_alloc(BMOperator *op, const char *slotname, int len) static void *bmo_slot_buffer_alloc(BMOperator *op, const char *slot_name, int len)
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF); BLI_assert(slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF);
/* check if its actually a buffer */ /* check if its actually a buffer */
if (slot->slottype != BMO_OP_SLOT_ELEMENT_BUF) if (slot->slot_type != BMO_OP_SLOT_ELEMENT_BUF)
return NULL; return NULL;
slot->len = len; slot->len = len;
if (len) if (len)
slot->data.buf = BLI_memarena_alloc(op->arena, BMO_OPSLOT_TYPEINFO[slot->slottype] * len); slot->data.buf = BLI_memarena_alloc(op->arena, BMO_OPSLOT_TYPEINFO[slot->slot_type] * len);
return slot->data.buf; return slot->data.buf;
} }
@@ -645,9 +645,9 @@ static void *bmo_slot_buffer_alloc(BMOperator *op, const char *slotname, int len
* *
* Copies all elements of a certain type into an operator slot. * Copies all elements of a certain type into an operator slot.
*/ */
static void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, const char *slotname, const char htype) static void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, const char *slot_name, const char htype)
{ {
BMOpSlot *output = BMO_slot_get(op, slotname); BMOpSlot *output = BMO_slot_get(op, slot_name);
int totelement = 0, i = 0; int totelement = 0, i = 0;
if (htype & BM_VERT) totelement += bm->totvert; if (htype & BM_VERT) totelement += bm->totvert;
@@ -658,7 +658,7 @@ static void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, const char *slot
BMIter iter; BMIter iter;
BMHeader *ele; BMHeader *ele;
bmo_slot_buffer_alloc(op, slotname, totelement); bmo_slot_buffer_alloc(op, slot_name, totelement);
/* TODO - collapse these loops into one */ /* TODO - collapse these loops into one */
@@ -691,11 +691,11 @@ static void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, const char *slot
* Copies elements of a certain type, which have a certain header flag * Copies elements of a certain type, which have a certain header flag
* enabled/disabled into a slot for an operator. * enabled/disabled into a slot for an operator.
*/ */
static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *slotname, static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *slot_name,
const char htype, const char hflag, const char htype, const char hflag,
const short test_for_enabled) const short test_for_enabled)
{ {
BMOpSlot *output = BMO_slot_get(op, slotname); BMOpSlot *output = BMO_slot_get(op, slot_name);
int totelement = 0, i = 0; int totelement = 0, i = 0;
BLI_assert(ELEM(test_for_enabled, TRUE, FALSE)); BLI_assert(ELEM(test_for_enabled, TRUE, FALSE));
@@ -709,7 +709,7 @@ static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *sl
BMIter iter; BMIter iter;
BMElem *ele; BMElem *ele;
bmo_slot_buffer_alloc(op, slotname, totelement); bmo_slot_buffer_alloc(op, slot_name, totelement);
/* TODO - collapse these loops into one */ /* TODO - collapse these loops into one */
@@ -751,16 +751,16 @@ static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, const char *sl
} }
} }
void BMO_slot_buffer_from_enabled_hflag(BMesh *bm, BMOperator *op, const char *slotname, void BMO_slot_buffer_from_enabled_hflag(BMesh *bm, BMOperator *op, const char *slot_name,
const char htype, const char hflag) const char htype, const char hflag)
{ {
bmo_slot_buffer_from_hflag(bm, op, slotname, htype, hflag, TRUE); bmo_slot_buffer_from_hflag(bm, op, slot_name, htype, hflag, TRUE);
} }
void BMO_slot_buffer_from_disabled_hflag(BMesh *bm, BMOperator *op, const char *slotname, void BMO_slot_buffer_from_disabled_hflag(BMesh *bm, BMOperator *op, const char *slot_name,
const char htype, const char hflag) const char htype, const char hflag)
{ {
bmo_slot_buffer_from_hflag(bm, op, slotname, htype, hflag, FALSE); bmo_slot_buffer_from_hflag(bm, op, slot_name, htype, hflag, FALSE);
} }
/** /**
@@ -772,15 +772,15 @@ void BMO_slot_buffer_append(BMOperator *output_op, const char *output_slot_name,
BMOpSlot *output_slot = BMO_slot_get(output_op, output_slot_name); BMOpSlot *output_slot = BMO_slot_get(output_op, output_slot_name);
BMOpSlot *other_slot = BMO_slot_get(other_op, other_slot_name); BMOpSlot *other_slot = BMO_slot_get(other_op, other_slot_name);
BLI_assert(output_slot->slottype == BMO_OP_SLOT_ELEMENT_BUF && BLI_assert(output_slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF &&
other_slot->slottype == BMO_OP_SLOT_ELEMENT_BUF); other_slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF);
if (output_slot->len == 0) { if (output_slot->len == 0) {
/* output slot is empty, copy rather than append */ /* output slot is empty, copy rather than append */
BMO_slot_copy(other_op, output_op, other_slot_name, output_slot_name); BMO_slot_copy(other_op, output_op, other_slot_name, output_slot_name);
} }
else if (other_slot->len != 0) { else if (other_slot->len != 0) {
int elem_size = BMO_OPSLOT_TYPEINFO[output_slot->slottype]; int elem_size = BMO_OPSLOT_TYPEINFO[output_slot->slot_type];
int alloc_size = elem_size * (output_slot->len + other_slot->len); int alloc_size = elem_size * (output_slot->len + other_slot->len);
/* allocate new buffer */ /* allocate new buffer */
void *buf = BLI_memarena_alloc(output_op->arena, alloc_size); void *buf = BLI_memarena_alloc(output_op->arena, alloc_size);
@@ -800,11 +800,11 @@ void BMO_slot_buffer_append(BMOperator *output_op, const char *output_slot_name,
* Copies elements of a certain type, which have a certain flag set * Copies elements of a certain type, which have a certain flag set
* into an output slot for an operator. * into an output slot for an operator.
*/ */
static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slotname, static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slot_name,
const char htype, const short oflag, const char htype, const short oflag,
const short test_for_enabled) const short test_for_enabled)
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
int totelement, i = 0; int totelement, i = 0;
BLI_assert(ELEM(TRUE, FALSE, test_for_enabled)); BLI_assert(ELEM(TRUE, FALSE, test_for_enabled));
@@ -814,14 +814,14 @@ static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slo
else else
totelement = BMO_mesh_disabled_flag_count(bm, htype, oflag); totelement = BMO_mesh_disabled_flag_count(bm, htype, oflag);
BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF); BLI_assert(slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF);
if (totelement) { if (totelement) {
BMIter iter; BMIter iter;
BMHeader *ele; BMHeader *ele;
BMHeader **ele_array; BMHeader **ele_array;
bmo_slot_buffer_alloc(op, slotname, totelement); bmo_slot_buffer_alloc(op, slot_name, totelement);
ele_array = (BMHeader **)slot->data.p; ele_array = (BMHeader **)slot->data.p;
@@ -859,16 +859,16 @@ static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, const char *slo
} }
} }
void BMO_slot_buffer_from_enabled_flag(BMesh *bm, BMOperator *op, const char *slotname, void BMO_slot_buffer_from_enabled_flag(BMesh *bm, BMOperator *op, const char *slot_name,
const char htype, const short oflag) const char htype, const short oflag)
{ {
bmo_slot_buffer_from_flag(bm, op, slotname, htype, oflag, TRUE); bmo_slot_buffer_from_flag(bm, op, slot_name, htype, oflag, TRUE);
} }
void BMO_slot_buffer_from_disabled_flag(BMesh *bm, BMOperator *op, const char *slotname, void BMO_slot_buffer_from_disabled_flag(BMesh *bm, BMOperator *op, const char *slot_name,
const char htype, const short oflag) const char htype, const short oflag)
{ {
bmo_slot_buffer_from_flag(bm, op, slotname, htype, oflag, FALSE); bmo_slot_buffer_from_flag(bm, op, slot_name, htype, oflag, FALSE);
} }
/** /**
@@ -877,16 +877,16 @@ void BMO_slot_buffer_from_disabled_flag(BMesh *bm, BMOperator *op, const char *s
* Header Flags elements in a slots buffer, automatically * Header Flags elements in a slots buffer, automatically
* using the selection API where appropriate. * using the selection API where appropriate.
*/ */
void BMO_slot_buffer_hflag_enable(BMesh *bm, BMOperator *op, const char *slotname, void BMO_slot_buffer_hflag_enable(BMesh *bm, BMOperator *op, const char *slot_name,
const char htype, const char hflag, const char do_flush) const char htype, const char hflag, const char do_flush)
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BMElem **data = slot->data.p; BMElem **data = slot->data.p;
int i; int i;
const char do_flush_select = (do_flush && (hflag & BM_ELEM_SELECT)); const char do_flush_select = (do_flush && (hflag & BM_ELEM_SELECT));
const char do_flush_hide = (do_flush && (hflag & BM_ELEM_HIDDEN)); const char do_flush_hide = (do_flush && (hflag & BM_ELEM_HIDDEN));
BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF); BLI_assert(slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF);
for (i = 0; i < slot->len; i++, data++) { for (i = 0; i < slot->len; i++, data++) {
if (!(htype & (*data)->head.htype)) if (!(htype & (*data)->head.htype))
@@ -910,16 +910,16 @@ void BMO_slot_buffer_hflag_enable(BMesh *bm, BMOperator *op, const char *slotnam
* Removes flags from elements in a slots buffer, automatically * Removes flags from elements in a slots buffer, automatically
* using the selection API where appropriate. * using the selection API where appropriate.
*/ */
void BMO_slot_buffer_hflag_disable(BMesh *bm, BMOperator *op, const char *slotname, void BMO_slot_buffer_hflag_disable(BMesh *bm, BMOperator *op, const char *slot_name,
const char htype, const char hflag, const char do_flush) const char htype, const char hflag, const char do_flush)
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BMElem **data = slot->data.p; BMElem **data = slot->data.p;
int i; int i;
const char do_flush_select = (do_flush && (hflag & BM_ELEM_SELECT)); const char do_flush_select = (do_flush && (hflag & BM_ELEM_SELECT));
const char do_flush_hide = (do_flush && (hflag & BM_ELEM_HIDDEN)); const char do_flush_hide = (do_flush && (hflag & BM_ELEM_HIDDEN));
BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF); BLI_assert(slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF);
for (i = 0; i < slot->len; i++, data++) { for (i = 0; i < slot->len; i++, data++) {
if (!(htype & (*data)->head.htype)) if (!(htype & (*data)->head.htype))
@@ -961,14 +961,14 @@ int BMO_vert_edge_flags_count(BMesh *bm, BMVert *v, const short oflag)
* *
* Flags elements in a slots buffer * Flags elements in a slots buffer
*/ */
void BMO_slot_buffer_flag_enable(BMesh *bm, BMOperator *op, const char *slotname, void BMO_slot_buffer_flag_enable(BMesh *bm, BMOperator *op, const char *slot_name,
const char htype, const short oflag) const char htype, const short oflag)
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BMHeader **data = slot->data.p; BMHeader **data = slot->data.p;
int i; int i;
BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF); BLI_assert(slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF);
for (i = 0; i < slot->len; i++) { for (i = 0; i < slot->len; i++) {
if (!(htype & data[i]->htype)) if (!(htype & data[i]->htype))
@@ -983,14 +983,14 @@ void BMO_slot_buffer_flag_enable(BMesh *bm, BMOperator *op, const char *slotname
* *
* Removes flags from elements in a slots buffer * Removes flags from elements in a slots buffer
*/ */
void BMO_slot_buffer_flag_disable(BMesh *bm, BMOperator *op, const char *slotname, void BMO_slot_buffer_flag_disable(BMesh *bm, BMOperator *op, const char *slot_name,
const char htype, const short oflag) const char htype, const short oflag)
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
BMHeader **data = slot->data.p; BMHeader **data = slot->data.p;
int i; int i;
BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF); BLI_assert(slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF);
for (i = 0; i < slot->len; i++) { for (i = 0; i < slot->len; i++) {
if (!(htype & data[i]->htype)) if (!(htype & data[i]->htype))
@@ -1131,11 +1131,11 @@ static void bmo_flag_layer_clear(BMesh *bm)
bm->elem_index_dirty &= ~(BM_VERT | BM_EDGE | BM_FACE); bm->elem_index_dirty &= ~(BM_VERT | BM_EDGE | BM_FACE);
} }
void *BMO_slot_buffer_elem_first(BMOperator *op, const char *slotname) void *BMO_slot_buffer_elem_first(BMOperator *op, const char *slot_name)
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
if (slot->slottype != BMO_OP_SLOT_ELEMENT_BUF) if (slot->slot_type != BMO_OP_SLOT_ELEMENT_BUF)
return NULL; return NULL;
return slot->data.buf ? *(void **)slot->data.buf : NULL; return slot->data.buf ? *(void **)slot->data.buf : NULL;
@@ -1148,9 +1148,9 @@ void *BMO_slot_buffer_elem_first(BMOperator *op, const char *slotname)
* (e.g. combination of BM_VERT, BM_EDGE, BM_FACE), if iterating * (e.g. combination of BM_VERT, BM_EDGE, BM_FACE), if iterating
* over an element buffer (not a mapping). */ * over an element buffer (not a mapping). */
void *BMO_iter_new(BMOIter *iter, BMesh *UNUSED(bm), BMOperator *op, void *BMO_iter_new(BMOIter *iter, BMesh *UNUSED(bm), BMOperator *op,
const char *slotname, const char restrictmask) const char *slot_name, const char restrictmask)
{ {
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
memset(iter, 0, sizeof(BMOIter)); memset(iter, 0, sizeof(BMOIter));
@@ -1158,7 +1158,7 @@ void *BMO_iter_new(BMOIter *iter, BMesh *UNUSED(bm), BMOperator *op,
iter->cur = 0; iter->cur = 0;
iter->restrictmask = restrictmask; iter->restrictmask = restrictmask;
if (iter->slot->slottype == BMO_OP_SLOT_MAPPING) { if (iter->slot->slot_type == BMO_OP_SLOT_MAPPING) {
if (iter->slot->data.ghash) { if (iter->slot->data.ghash) {
BLI_ghashIterator_init(&iter->giter, slot->data.ghash); BLI_ghashIterator_init(&iter->giter, slot->data.ghash);
} }
@@ -1172,7 +1172,7 @@ void *BMO_iter_new(BMOIter *iter, BMesh *UNUSED(bm), BMOperator *op,
void *BMO_iter_step(BMOIter *iter) void *BMO_iter_step(BMOIter *iter)
{ {
if (iter->slot->slottype == BMO_OP_SLOT_ELEMENT_BUF) { if (iter->slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF) {
BMHeader *h; BMHeader *h;
if (iter->cur >= iter->slot->len) { if (iter->cur >= iter->slot->len) {
@@ -1190,7 +1190,7 @@ void *BMO_iter_step(BMOIter *iter)
return h; return h;
} }
else if (iter->slot->slottype == BMO_OP_SLOT_MAPPING) { else if (iter->slot->slot_type == BMO_OP_SLOT_MAPPING) {
BMOElemMapping *map; BMOElemMapping *map;
void *ret = BLI_ghashIterator_getKey(&iter->giter); void *ret = BLI_ghashIterator_getKey(&iter->giter);
map = BLI_ghashIterator_getValue(&iter->giter); map = BLI_ghashIterator_getValue(&iter->giter);
@@ -1286,8 +1286,8 @@ static int bmo_name_to_slotcode(BMOpDefine *def, const char *name)
{ {
int i; int i;
for (i = 0; def->slottypes[i].type; i++) { for (i = 0; def->slot_types[i].type; i++) {
if (!strncmp(name, def->slottypes[i].name, MAX_SLOTNAME)) { if (!strncmp(name, def->slot_types[i].name, MAX_SLOTNAME)) {
return i; return i;
} }
} }
@@ -1331,14 +1331,17 @@ static int bmo_opname_to_opcode(const char *opname)
* fv - flagged verts (oflag) * fv - flagged verts (oflag)
* fe - flagged edges (oflag) * fe - flagged edges (oflag)
* ff - flagged faces (oflag) * ff - flagged faces (oflag)
*
* capitals - H, F to use the flag flipped (when the flag is off)
* Hv, He, Hf, Fv, Fe, Ff,
*/ */
int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist) int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
{ {
BMOpDefine *def; BMOpDefine *def;
char *opname, *ofmt, *fmt; char *opname, *ofmt, *fmt;
char slotname[64] = {0}; char slot_name[64] = {0};
int i /*, n = strlen(fmt) */, stop /*, slotcode = -1 */, type, state; int i /*, n = strlen(fmt) */, stop /*, slot_code = -1 */, type, state;
char htype; char htype;
int noslot = 0; int noslot = 0;
@@ -1377,7 +1380,7 @@ int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
def = opdefines[i]; def = opdefines[i];
i = 0; i = 0;
state = 1; /* 0: not inside slotcode name, 1: inside slotcode name */ state = 1; /* 0: not inside slot_code name, 1: inside slot_code name */
while (*fmt) { while (*fmt) {
if (state) { if (state) {
@@ -1401,7 +1404,7 @@ int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
GOTO_ERROR("name to slot code check failed"); GOTO_ERROR("name to slot code check failed");
} }
BLI_strncpy(slotname, fmt, sizeof(slotname)); BLI_strncpy(slot_name, fmt, sizeof(slot_name));
state = 0; state = 0;
fmt += i; fmt += i;
@@ -1422,18 +1425,18 @@ int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
else if (c == '4') size = 4; else if (c == '4') size = 4;
else GOTO_ERROR("matrix size was not 3 or 4"); else GOTO_ERROR("matrix size was not 3 or 4");
BMO_slot_mat_set(op, slotname, va_arg(vlist, void *), size); BMO_slot_mat_set(op, slot_name, va_arg(vlist, void *), size);
state = 1; state = 1;
break; break;
} }
case 'v': { case 'v': {
BMO_slot_vec_set(op, slotname, va_arg(vlist, float *)); BMO_slot_vec_set(op, slot_name, va_arg(vlist, float *));
state = 1; state = 1;
break; break;
} }
case 'e': { case 'e': {
BMHeader *ele = va_arg(vlist, void *); BMHeader *ele = va_arg(vlist, void *);
BMOpSlot *slot = BMO_slot_get(op, slotname); BMOpSlot *slot = BMO_slot_get(op, slot_name);
slot->data.buf = BLI_memarena_alloc(op->arena, sizeof(void *) * 4); slot->data.buf = BLI_memarena_alloc(op->arena, sizeof(void *) * 4);
slot->len = 1; slot->len = 1;
@@ -1444,22 +1447,22 @@ int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
} }
case 's': { case 's': {
BMOperator *op2 = va_arg(vlist, void *); BMOperator *op2 = va_arg(vlist, void *);
const char *slotname2 = va_arg(vlist, char *); const char *slot_name2 = va_arg(vlist, char *);
BMO_slot_copy(op2, op, slotname2, slotname); BMO_slot_copy(op2, op, slot_name2, slot_name);
state = 1; state = 1;
break; break;
} }
case 'i': case 'i':
BMO_slot_int_set(op, slotname, va_arg(vlist, int)); BMO_slot_int_set(op, slot_name, va_arg(vlist, int));
state = 1; state = 1;
break; break;
case 'b': case 'b':
BMO_slot_bool_set(op, slotname, va_arg(vlist, int)); BMO_slot_bool_set(op, slot_name, va_arg(vlist, int));
state = 1; state = 1;
break; break;
case 'p': case 'p':
BMO_slot_ptr_set(op, slotname, va_arg(vlist, void *)); BMO_slot_ptr_set(op, slot_name, va_arg(vlist, void *));
state = 1; state = 1;
break; break;
case 'f': case 'f':
@@ -1470,7 +1473,7 @@ int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
type = *fmt; type = *fmt;
if (NEXT_CHAR(fmt) == ' ' || NEXT_CHAR(fmt) == '\0') { if (NEXT_CHAR(fmt) == ' ' || NEXT_CHAR(fmt) == '\0') {
BMO_slot_float_set(op, slotname, va_arg(vlist, double)); BMO_slot_float_set(op, slot_name, va_arg(vlist, double));
} }
else { else {
htype = 0; htype = 0;
@@ -1492,19 +1495,19 @@ int BMO_op_vinitf(BMesh *bm, BMOperator *op, const char *_fmt, va_list vlist)
} }
if (type == 'h') { if (type == 'h') {
BMO_slot_buffer_from_enabled_hflag(bm, op, slotname, htype, va_arg(vlist, int)); BMO_slot_buffer_from_enabled_hflag(bm, op, slot_name, htype, va_arg(vlist, int));
} }
else if (type == 'H') { else if (type == 'H') {
BMO_slot_buffer_from_disabled_hflag(bm, op, slotname, htype, va_arg(vlist, int)); BMO_slot_buffer_from_disabled_hflag(bm, op, slot_name, htype, va_arg(vlist, int));
} }
else if (type == 'a') { else if (type == 'a') {
BMO_slot_buffer_from_all(bm, op, slotname, htype); BMO_slot_buffer_from_all(bm, op, slot_name, htype);
} }
else if (type == 'f') { else if (type == 'f') {
BMO_slot_buffer_from_enabled_flag(bm, op, slotname, htype, va_arg(vlist, int)); BMO_slot_buffer_from_enabled_flag(bm, op, slot_name, htype, va_arg(vlist, int));
} }
else if (type == 'F') { else if (type == 'F') {
BMO_slot_buffer_from_disabled_flag(bm, op, slotname, htype, va_arg(vlist, int)); BMO_slot_buffer_from_disabled_flag(bm, op, slot_name, htype, va_arg(vlist, int));
} }
} }

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

@@ -4998,7 +4998,6 @@ void projectSVData(TransInfo *t, int final)
BMEditMesh *em = sld->em; BMEditMesh *em = sld->em;
SmallHash visit; SmallHash visit;
int i; int i;
short has_uv;
if (!em) if (!em)
return; return;
@@ -5011,8 +5010,6 @@ void projectSVData(TransInfo *t, int final)
if (em->bm->shapenr > 1) if (em->bm->shapenr > 1)
return; return;
has_uv = CustomData_has_layer(&(em->bm->ldata), CD_MLOOPUV);
BLI_smallhash_init(&visit); BLI_smallhash_init(&visit);
for (i = 0, sv = sld->sv; i < sld->totsv; sv++, i++) { for (i = 0, sv = sld->sv; i < sld->totsv; sv++, i++) {