75 if (index_absolute != -1) {
76 return &
data->layers[index_absolute];
79 PyErr_SetString(PyExc_RuntimeError,
"layer has become invalid");
93 bpy_bmlayeraccess_collection__float_doc,
94 "Generic float custom-data layer.\n"
96 ":type: :class:`bmesh.types.BMLayerCollection`\\ [float]\n");
99 bpy_bmlayeraccess_collection__int_doc,
100 "Generic int custom-data layer.\n"
102 ":type: :class:`bmesh.types.BMLayerCollection`\\ [int]\n");
105 bpy_bmlayeraccess_collection__bool_doc,
106 "Generic boolean custom-data layer.\n"
108 ":type: :class:`bmesh.types.BMLayerCollection`\\ [bool]\n");
111 bpy_bmlayeraccess_collection__float_vector_doc,
112 "Generic 3D vector with float precision custom-data layer.\n"
114 ":type: :class:`bmesh.types.BMLayerCollection`\\ [:class:`mathutils.Vector`]\n");
117 bpy_bmlayeraccess_collection__float_color_doc,
118 "Generic RGBA color with float precision custom-data layer.\n"
120 ":type: :class:`bmesh.types.BMLayerCollection`\\ [:class:`mathutils.Vector`]\n");
123 bpy_bmlayeraccess_collection__color_doc,
124 "Generic RGBA color with 8-bit precision custom-data layer.\n"
126 ":type: :class:`bmesh.types.BMLayerCollection`\\ [:class:`mathutils.Vector`]\n");
129 bpy_bmlayeraccess_collection__string_doc,
130 "Generic string custom-data layer (exposed as bytes, 255 max length).\n"
132 ":type: :class:`bmesh.types.BMLayerCollection`\\ [bytes]\n");
135 bpy_bmlayeraccess_collection__deform_doc,
136 "Vertex deform weight :class:`bmesh.types.BMDeformVert` (TODO).\n"
140 ":class:`bmesh.types.BMLayerCollection`\\ [:class:`bmesh.types.BMDeformVert`]");
143 bpy_bmlayeraccess_collection__shape_doc,
144 "Vertex shape-key absolute location (as a 3D Vector).\n"
146 ":type: :class:`bmesh.types.BMLayerCollection`\\ [:class:`mathutils.Vector`]\n");
149 bpy_bmlayeraccess_collection__uv_doc,
150 "Accessor for :class:`bmesh.types.BMLoopUV` UV (as a 2D Vector).\n"
152 ":type: :class:`bmesh.types.BMLayerCollection`\\ [:class:`bmesh.types.BMLoopUV`]\n");
155 bpy_bmlayeraccess_collection__skin_doc,
156 "Accessor for skin layer.\n"
158 ":type: :class:`bmesh.types.BMLayerCollection`\\ [:class:`bmesh.types.BMVertSkin`]\n");
171 bpy_bmlayercollection_active_doc,
172 "The active layer of this type (read-only).\n"
174 ":type: :class:`bmesh.types.BMLayerItem` | None\n");
199 bpy_bmlayercollection_is_singleton_doc,
200 "True if there can exist only one layer of this type (read-only).\n"
216 bpy_bmlayercollection_name_doc,
217 "The layer's unique name (read-only).\n"
228 return PyUnicode_FromString(
layer->name);
237 static_cast<setter
>(
nullptr),
238 bpy_bmlayeraccess_collection__deform_doc,
243 static_cast<setter
>(
nullptr),
244 bpy_bmlayeraccess_collection__float_doc,
248 static_cast<setter
>(
nullptr),
249 bpy_bmlayeraccess_collection__bool_doc,
253 static_cast<setter
>(
nullptr),
254 bpy_bmlayeraccess_collection__int_doc,
258 static_cast<setter
>(
nullptr),
259 bpy_bmlayeraccess_collection__float_vector_doc,
263 static_cast<setter
>(
nullptr),
264 bpy_bmlayeraccess_collection__float_color_doc,
268 static_cast<setter
>(
nullptr),
269 bpy_bmlayeraccess_collection__color_doc,
273 static_cast<setter
>(
nullptr),
274 bpy_bmlayeraccess_collection__string_doc,
279 static_cast<setter
>(
nullptr),
280 bpy_bmlayeraccess_collection__shape_doc,
284 static_cast<setter
>(
nullptr),
285 bpy_bmlayeraccess_collection__skin_doc,
287 {
nullptr,
nullptr,
nullptr,
nullptr,
nullptr}
293 static_cast<setter
>(
nullptr),
294 bpy_bmlayeraccess_collection__float_doc,
298 static_cast<setter
>(
nullptr),
299 bpy_bmlayeraccess_collection__int_doc,
303 static_cast<setter
>(
nullptr),
304 bpy_bmlayeraccess_collection__bool_doc,
308 static_cast<setter
>(
nullptr),
309 bpy_bmlayeraccess_collection__float_vector_doc,
313 static_cast<setter
>(
nullptr),
314 bpy_bmlayeraccess_collection__float_color_doc,
318 static_cast<setter
>(
nullptr),
319 bpy_bmlayeraccess_collection__color_doc,
323 static_cast<setter
>(
nullptr),
324 bpy_bmlayeraccess_collection__string_doc,
326 {
nullptr,
nullptr,
nullptr,
nullptr,
nullptr}
332 static_cast<setter
>(
nullptr),
333 bpy_bmlayeraccess_collection__float_doc,
337 static_cast<setter
>(
nullptr),
338 bpy_bmlayeraccess_collection__int_doc,
342 static_cast<setter
>(
nullptr),
343 bpy_bmlayeraccess_collection__bool_doc,
347 static_cast<setter
>(
nullptr),
348 bpy_bmlayeraccess_collection__float_vector_doc,
352 static_cast<setter
>(
nullptr),
353 bpy_bmlayeraccess_collection__float_color_doc,
357 static_cast<setter
>(
nullptr),
358 bpy_bmlayeraccess_collection__color_doc,
362 static_cast<setter
>(
nullptr),
363 bpy_bmlayeraccess_collection__string_doc,
366 {
nullptr,
nullptr,
nullptr,
nullptr,
nullptr}
372 static_cast<setter
>(
nullptr),
373 bpy_bmlayeraccess_collection__float_doc,
377 static_cast<setter
>(
nullptr),
378 bpy_bmlayeraccess_collection__int_doc,
382 static_cast<setter
>(
nullptr),
383 bpy_bmlayeraccess_collection__bool_doc,
387 static_cast<setter
>(
nullptr),
388 bpy_bmlayeraccess_collection__float_vector_doc,
392 static_cast<setter
>(
nullptr),
393 bpy_bmlayeraccess_collection__float_color_doc,
397 static_cast<setter
>(
nullptr),
398 bpy_bmlayeraccess_collection__string_doc,
402 static_cast<setter
>(
nullptr),
403 bpy_bmlayeraccess_collection__uv_doc,
407 static_cast<setter
>(
nullptr),
408 bpy_bmlayeraccess_collection__color_doc,
411 {
nullptr,
nullptr,
nullptr,
nullptr,
nullptr}
418 static_cast<setter
>(
nullptr),
419 bpy_bmlayercollection_active_doc,
423 static_cast<setter
>(
nullptr),
424 bpy_bmlayercollection_is_singleton_doc,
427 {
nullptr,
nullptr,
nullptr,
nullptr,
nullptr}
434 static_cast<setter
>(
nullptr),
435 bpy_bmlayercollection_name_doc,
438 {
nullptr,
nullptr,
nullptr,
nullptr,
nullptr}
449 bpy_bmlayeritem_copy_from_doc,
450 ".. method:: copy_from(other)\n"
452 " Copy data from another layer.\n"
454 " :param other: Another layer to copy from.\n"
455 " :type other: :class:`bmesh.types.BMLayerItem`\n");
458 const char *error_prefix =
"layer.copy_from(...)";
462 PyErr_Format(PyExc_TypeError,
463 "%s: expected BMLayerItem, not '%.200s'",
465 Py_TYPE(value)->tp_name);
473 PyErr_Format(PyExc_ValueError,
"%s: layer type mismatch", error_prefix);
498 bpy_bmlayercollection_verify_doc,
499 ".. method:: verify()\n"
501 " Create a new layer or return an existing active layer\n"
503 " :return: The newly created layer, or the existing active layer.\n"
504 " :rtype: :class:`bmesh.types.BMLayerItem`\n");
548 bpy_bmlayercollection_new_doc,
549 ".. method:: new(name=\"\")\n"
551 " Create a new layer\n"
553 " :param name: Optional name argument (will be made unique).\n"
555 " :return: The newly created layer.\n"
556 " :rtype: :class:`bmesh.types.BMLayerItem`\n");
559 const char *name =
nullptr;
565 if (!PyArg_ParseTuple(args,
578 PyErr_SetString(PyExc_ValueError,
"layers.new(): is a singleton, use verify() instead");
593 PyErr_SetString(PyExc_ValueError,
"layers.new(): is a singleton, use verify() instead");
619 bpy_bmlayercollection_remove_doc,
620 ".. method:: remove(layer)\n"
624 " :param layer: The layer to remove.\n"
625 " :type layer: :class:`bmesh.types.BMLayerItem`\n");
633 PyErr_Format(PyExc_TypeError,
634 "layers.remove(x): expected BMLayerItem, not '%.200s'",
635 Py_TYPE(value)->tp_name);
642 PyErr_SetString(PyExc_ValueError,
"layers.remove(x): x not in layers");
661 bpy_bmlayercollection_keys_doc,
662 ".. method:: keys()\n"
664 " Return the identifiers of collection members\n"
665 " (matching Python's dict.keys() functionality).\n"
667 " :return: the identifiers for each member of this collection.\n"
668 " :rtype: list[str]\n");
683 return PyList_New(0);
695 ret = PyList_New(tot);
697 for (i = 0; tot-- > 0;
index++) {
698 item = PyUnicode_FromString(
data->layers[
index].name);
699 PyList_SET_ITEM(
ret, i++, item);
707 bpy_bmlayercollection_items_doc,
708 ".. method:: items()\n"
710 " Return the (key, value) pairs of collection members\n"
711 " (matching Python's dict.items() functionality).\n"
713 " :return: (key, value) pairs for each member of this collection.\n"
714 " :rtype: list[tuple[str, :class:`bmesh.types.BMLayerItem`]]\n");
730 return PyList_New(0);
733 item = PyTuple_New(2);
737 PyList_SET_ITEM(
ret, 0, item);
744 ret = PyList_New(tot);
746 for (i = 0; tot-- > 0;
index++) {
747 item = PyTuple_New(2);
749 PyUnicode_FromString(
data->layers[
index].name),
751 PyList_SET_ITEM(
ret, i++, item);
759 bpy_bmlayercollection_values_doc,
760 ".. method:: values()\n"
762 " Return the values of collection\n"
763 " (matching Python's dict.values() functionality).\n"
765 " :return: the members of this collection.\n"
766 " :rtype: list[:class:`bmesh.types.BMLayerItem`]\n");
782 return PyList_New(0);
793 ret = PyList_New(tot);
795 for (i = 0; tot-- > 0;
index++) {
797 PyList_SET_ITEM(
ret, i++, item);
805 bpy_bmlayercollection_get_doc,
806 ".. method:: get(key, default=None)\n"
808 " Returns the value of the layer matching the key or default\n"
809 " when not found (matches Python's dictionary function of the same name).\n"
811 " :param key: The key associated with the layer.\n"
813 " :param default: Optional argument for the value to return if\n"
814 " *key* is not found.\n"
815 " :type default: Any\n"
816 " :return: The layer matching the key or the default value.\n"
817 " :rtype: :class:`bmesh.types.BMLayerItem` | Any\n");
821 PyObject *def = Py_None;
825 if (!PyArg_ParseTuple(args,
853 return Py_NewRef(def);
860 bpy_bmlayeritem_copy_from_doc},
861 {
nullptr,
nullptr, 0,
nullptr},
866# pragma clang diagnostic push
867# pragma clang diagnostic ignored "-Wcast-function-type"
869# pragma GCC diagnostic push
870# pragma GCC diagnostic ignored "-Wcast-function-type"
878 bpy_bmlayercollection_verify_doc},
882 bpy_bmlayercollection_new_doc},
886 bpy_bmlayercollection_remove_doc},
891 bpy_bmlayercollection_keys_doc},
895 bpy_bmlayercollection_values_doc},
899 bpy_bmlayercollection_items_doc},
903 bpy_bmlayercollection_get_doc},
904 {
nullptr,
nullptr, 0,
nullptr},
909# pragma clang diagnostic pop
911# pragma GCC diagnostic pop
956 PyErr_Format(PyExc_KeyError,
"BMLayerCollection[key]: key \"%.200s\" not found", keyname);
984 PyErr_Format(PyExc_IndexError,
"BMLayerCollection[index]: index %d out of range", keynum);
999 start = std::min(start,
len);
1000 stop = std::min(stop,
len);
1002 tuple = PyTuple_New(stop - start);
1004 for (count = start; count < stop; count++) {
1014 if (PyUnicode_Check(key)) {
1017 if (PyIndex_Check(key)) {
1018 const Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError);
1019 if (i == -1 && PyErr_Occurred()) {
1024 if (PySlice_Check(key)) {
1025 PySliceObject *key_slice =
reinterpret_cast<PySliceObject *
>(key);
1026 Py_ssize_t
step = 1;
1028 if (key_slice->step != Py_None && !_PyEval_SliceIndex(key_slice->step, &
step)) {
1032 PyErr_SetString(PyExc_TypeError,
"BMLayerCollection[slice]: slice steps not supported");
1035 if (key_slice->start == Py_None && key_slice->stop == Py_None) {
1039 Py_ssize_t start = 0, stop = PY_SSIZE_T_MAX;
1042 if (key_slice->start != Py_None && !_PyEval_SliceIndex(key_slice->start, &start)) {
1045 if (key_slice->stop != Py_None && !_PyEval_SliceIndex(key_slice->stop, &stop)) {
1049 if (start < 0 || stop < 0) {
1062 if (stop - start <= 0) {
1063 return PyTuple_New(0);
1069 PyErr_SetString(PyExc_AttributeError,
"BMLayerCollection[key]: invalid key, key must be an int");
1075 const char *keyname = PyUnicode_AsUTF8(value);
1081 if (keyname ==
nullptr) {
1082 PyErr_SetString(PyExc_TypeError,
"BMLayerCollection.__contains__: expected a string");
1096 return (
index != -1) ? 1 : 0;
1116 static_cast<objobjargproc
>(
nullptr),
1126 PyObject *iter =
nullptr;
1133 iter = PyObject_GetIter(
ret);
1142 bpy_bmlayeraccess_type_doc,
1143 "Exposes custom-data layer attributes.\n");
1146 bpy_bmlayercollection_type_doc,
1147 "Gives access to a collection of custom-data layers of the same type and behaves "
1148 "like Python dictionaries, "
1149 "except for the ability to do list like index access.\n");
1152 bpy_bmlayeritem_type_doc,
1153 "Exposes a single custom data layer, "
1154 "its main purpose is for use as an item accessor to custom-data when used with "
1155 "vert/edge/face/loop data.\n");
1191 self->
htype = htype;
1192 return reinterpret_cast<PyObject *
>(self);
1199 self->
htype = htype;
1201 return reinterpret_cast<PyObject *
>(self);
1208 self->
htype = htype;
1211 return reinterpret_cast<PyObject *
>(self);
1298 PyErr_SetString(PyExc_AttributeError,
"BMElem[key]: invalid key, must be a BMLayerItem");
1301 if (py_ele->
bm != py_layer->
bm) [[unlikely]] {
1302 PyErr_SetString(PyExc_ValueError,
"BMElem[layer]: layer is from another mesh");
1306 char namestr_1[32], namestr_2[32];
1307 PyErr_Format(PyExc_ValueError,
1308 "Layer/Element type mismatch, expected %.200s got layer type %.200s",
1321 if (value ==
nullptr) [[unlikely]] {
1323 PyErr_SetString(PyExc_KeyError,
"BMElem[key]: layer not found");
1335 if (value ==
nullptr) [[unlikely]] {
1339 switch (py_layer->
type) {
1345 ret = PyFloat_FromDouble(*
static_cast<float *
>(value));
1349 ret = PyLong_FromLong(*
static_cast<int *
>(value));
1353 ret = PyBool_FromLong(*
static_cast<bool *
>(value));
1366 ret = PyBytes_FromStringAndSize(mstring->
s, mstring->
s_len);
1370 if (py_ele->
bm != py_layer->
bm) [[unlikely]] {
1371 PyErr_SetString(PyExc_ValueError,
"BMElem[layer]: layer is from another mesh");
1391 ret = Py_NotImplemented;
1405 if (value ==
nullptr) [[unlikely]] {
1409 switch (py_layer->
type) {
1415 const float tmp_val = PyFloat_AsDouble(py_value);
1416 if (tmp_val == -1 && PyErr_Occurred()) [[unlikely]] {
1418 PyExc_TypeError,
"expected a float, not a %.200s", Py_TYPE(py_value)->tp_name);
1422 *
static_cast<float *
>(value) = tmp_val;
1427 const int tmp_val = PyC_Long_AsI32(py_value);
1428 if (tmp_val == -1 && PyErr_Occurred()) [[unlikely]] {
1433 *
static_cast<int *
>(value) = tmp_val;
1439 if (tmp_val == -1) [[unlikely]] {
1444 *
static_cast<bool *
>(value) = tmp_val;
1450 static_cast<float *
>(value), 3, 3, py_value,
"BMElem Float Vector") == -1)
1458 static_cast<float *
>(value), 4, 4, py_value,
"BMElem Float Color") == -1)
1467 Py_ssize_t tmp_val_len;
1468 if (PyBytes_AsStringAndSize(py_value, &tmp_val, &tmp_val_len) == -1) [[unlikely]] {
1469 PyErr_Format(PyExc_TypeError,
"expected bytes, not a %.200s", Py_TYPE(py_value)->tp_name);
1473 tmp_val_len = std::min<ulong>(tmp_val_len,
sizeof(mstring->
s));
1474 memcpy(mstring->
s, tmp_val, tmp_val_len);
1475 mstring->
s_len = tmp_val_len;
1480 if (py_ele->
bm != py_layer->
bm) [[unlikely]] {
1481 PyErr_SetString(PyExc_ValueError,
"BMElem[layer]: layer is from another mesh");
1486 py_ele->
bm,
reinterpret_cast<BMLoop *
>(py_ele->
ele), py_value);
1502 copy_v3_v3(
static_cast<float *
>(value), tmp_val);
1508 py_ele->
bm,
reinterpret_cast<BMVert *
>(py_ele->
ele), py_value);
1512 PyErr_SetString(PyExc_AttributeError,
"readonly / unsupported type");
CustomData interface, see also DNA_customdata_types.h.
#define BLI_assert_unreachable()
#define POINTER_AS_INT(i)
#define BPY_BM_CHECK_OBJ(obj)
#define BPY_BM_CHECK_SOURCE_OBJ(bm, errmsg,...)
#define BPY_BM_CHECK_INT(obj)
#define BPy_BMLayerItem_Check(v)
VecBase< float, D > step(VecOp< float, D >, VecOp< float, D >) RET
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
static PyObject * bpy_bmlayercollection_verify(BPy_BMLayerCollection *self)
bool BM_data_layer_free_named(BMesh *bm, CustomData *data, StringRef name)
static int bpy_bmlayercollection_contains(BPy_BMLayerCollection *self, PyObject *value)
static PyObject * bpy_bmlayercollection_remove(BPy_BMLayerCollection *self, BPy_BMLayerItem *value)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static PyGetSetDef bpy_bmlayeraccess_edge_getseters[]
PyTypeObject BPy_BMLayerAccessVert_Type
void BM_data_layer_free_n(BMesh *bm, CustomData *data, int type, int n)
void BM_data_layer_add(BMesh *bm, CustomData *data, int type)
PyObject * BPy_BMLayerItem_CreatePyObject(BMesh *bm, const char htype, int type, int index)
static PyObject * bpy_bmlayercollection_subscript_str(BPy_BMLayerCollection *self, const char *keyname)
static PyObject * bpy_bmlayeraccess_collection_get(BPy_BMLayerAccess *self, void *flag)
int CustomData_number_of_layers(const CustomData *data, eCustomDataType type)
PyObject * BPy_BMLayerCollection_CreatePyObject(BMesh *bm, const char htype, int type)
static CustomData * bpy_bm_customdata_get(BMesh *bm, char htype)
MINLINE void copy_v3_v3(float r[3], const float a[3])
PyObject * BPy_BMDeformVert_CreatePyObject(MDeformVert *dvert)
static const char * bpy_bm_layer_skin_radius_name
bool CustomData_has_layer(const CustomData *data, eCustomDataType type)
PyTypeObject BPy_BMLayerAccessFace_Type
static PyMethodDef bpy_bmelemseq_methods[]
static PyObject * bpy_bmlayercollection_active_get(BPy_BMLayerItem *self, void *)
PyObject * Vector_CreatePyObject_wrap(float *vec, const int vec_num, PyTypeObject *base_type)
PyDoc_STRVAR(bpy_bm_new_doc, ".. function:: new(*, use_operators=True)\n" "\n" " :param use_operators: Support calling operators in :mod:`bmesh.ops` (uses some " "extra memory per vert/edge/face).\n" " :type use_operators: bool\n" " :return: Return a new, empty BMesh.\n" " :rtype: :class:`bmesh.types.BMesh`\n")
static PyObject * bpy_bmlayercollection_new(BPy_BMLayerCollection *self, PyObject *args)
static PyObject * bpy_bmlayercollection_subscript_slice(BPy_BMLayerCollection *self, Py_ssize_t start, Py_ssize_t stop)
constexpr int BPY_BM_LAYER_TYPE_SKIN
static void * bpy_bmlayeritem_ptr_get(BPy_BMElem *py_ele, BPy_BMLayerItem *py_layer)
static PyGetSetDef bpy_bmlayeraccess_vert_getseters[]
static PyObject * bpy_bmlayercollection_items(BPy_BMLayerCollection *self)
PyObject * BPy_BMLoopColor_CreatePyObject(MLoopCol *mloopcol)
int CustomData_get_layer_index(const CustomData *data, eCustomDataType type)
static const char * bpy_bm_layer_skin_root_name
PyObject * BPy_BMVertSkin_CreatePyObject(BMesh *bm, BMVert *vert)
PyObject * BPy_BMLayerAccess_CreatePyObject(BMesh *bm, const char htype)
void BPy_BM_init_types_customdata()
static PyObject * bpy_bmlayercollection_get(BPy_BMLayerCollection *self, PyObject *args)
PyObject * BPy_BMLayerItem_GetItem(BPy_BMElem *py_ele, BPy_BMLayerItem *py_layer)
BMElem.__getitem__() / __setitem__()
bool CustomData_layertype_is_singleton(eCustomDataType type)
PyTypeObject BPy_BMLayerCollection_Type
int BPy_BMLayerItem_SetItem(BPy_BMElem *py_ele, BPy_BMLayerItem *py_layer, PyObject *py_value)
static PyObject * bpy_bmlayercollection_values(BPy_BMLayerCollection *self)
static PyGetSetDef bpy_bmlayeraccess_face_getseters[]
BMesh const char void * data
int BPy_BMLoopUV_AssignPyObject(BMesh *bm, BMLoop *loop, PyObject *value)
static PyObject * bpy_bmlayeritem_name_get(BPy_BMLayerItem *self, void *)
static PyMappingMethods bpy_bmlayercollection_as_mapping
static PyObject * bpy_bmlayeritem_copy_from(BPy_BMLayerItem *self, BPy_BMLayerItem *value)
int mathutils_array_parse(float *array, int array_num_min, int array_num_max, PyObject *value, const char *error_prefix)
static PyObject * bpy_bmlayercollection_iter(BPy_BMLayerCollection *self)
PyTypeObject BPy_BMLayerItem_Type
static PyObject * bpy_bmlayercollection_is_singleton_get(BPy_BMLayerItem *self, void *)
int CustomData_get_named_layer_index(const CustomData *data, eCustomDataType type, StringRef name)
PyTypeObject BPy_BMLayerAccessLoop_Type
int PyC_Long_AsBool(PyObject *value)
int BPy_BMLoopColor_AssignPyObject(MLoopCol *mloopcol, PyObject *value)
int CustomData_get_layer_index_n(const CustomData *data, eCustomDataType type, int n)
static PyGetSetDef bpy_bmlayeraccess_loop_getseters[]
PyTypeObject BPy_BMLayerAccessEdge_Type
static Py_ssize_t bpy_bmlayercollection_length(BPy_BMLayerCollection *self)
static PyGetSetDef bpy_bmlayercollection_getseters[]
static PyGetSetDef bpy_bmlayeritem_getseters[]
static PyObject * bpy_bmlayercollection_subscript_int(BPy_BMLayerCollection *self, Py_ssize_t keynum)
static CustomDataLayer * bpy_bmlayeritem_get(BPy_BMLayerItem *self)
void BM_data_layer_copy(BMesh *bm, CustomData *data, int type, int src_n, int dst_n)
static PyObject * bpy_bmlayercollection_subscript(BPy_BMLayerCollection *self, PyObject *key)
char * BPy_BMElem_StringFromHType_ex(const char htype, char ret[32])
int CustomData_get_active_layer(const CustomData *data, eCustomDataType type)
PyObject * BPy_BMLoopUV_CreatePyObject(BMesh *bm, BMLoop *loop, int layer)
int BPy_BMDeformVert_AssignPyObject(MDeformVert *dvert, PyObject *value)
void BM_data_layer_add_named(BMesh *bm, CustomData *data, int type, const StringRef name)
void BM_uv_map_attr_pin_ensure_for_all_layers(BMesh *bm)
int BPy_BMVertSkin_AssignPyObject(BMesh *bm, BMVert *vert, PyObject *value)
bool CustomData_has_layer_named(const CustomData *data, eCustomDataType type, StringRef name)
static PySequenceMethods bpy_bmlayercollection_as_sequence
static const char * bpy_bm_layer_skin_loose_name
int CustomData_get_named_layer(const CustomData *data, eCustomDataType type, StringRef name)
static bool bpy_bm_layer_type_is_skin(const int type)
static PyObject * bpy_bmlayercollection_keys(BPy_BMLayerCollection *self)
static PyMethodDef bpy_bmlayeritem_methods[]
void * CustomData_bmesh_get_n(const CustomData *data, void *block, eCustomDataType type, int n)
#define PyTuple_SET_ITEMS(op_arg,...)