diff options
author | Campbell Barton <ideasman42@gmail.com> | 2019-04-17 07:17:24 +0300 |
---|---|---|
committer | Campbell Barton <ideasman42@gmail.com> | 2019-04-17 07:21:24 +0300 |
commit | e12c08e8d170b7ca40f204a5b0423c23a9fbc2c1 (patch) | |
tree | 8cf3453d12edb177a218ef8009357518ec6cab6a /source/blender/python/bmesh/bmesh_py_types_customdata.c | |
parent | b3dabc200a4b0399ec6b81f2ff2730d07b44fcaa (diff) |
ClangFormat: apply to source, most of intern
Apply clang format as proposed in T53211.
For details on usage and instructions for migrating branches
without conflicts, see:
https://wiki.blender.org/wiki/Tools/ClangFormat
Diffstat (limited to 'source/blender/python/bmesh/bmesh_py_types_customdata.c')
-rw-r--r-- | source/blender/python/bmesh/bmesh_py_types_customdata.c | 1736 |
1 files changed, 901 insertions, 835 deletions
diff --git a/source/blender/python/bmesh/bmesh_py_types_customdata.c b/source/blender/python/bmesh/bmesh_py_types_customdata.c index abe146f2581..56c25edb7e4 100644 --- a/source/blender/python/bmesh/bmesh_py_types_customdata.c +++ b/source/blender/python/bmesh/bmesh_py_types_customdata.c @@ -45,29 +45,32 @@ static CustomData *bpy_bm_customdata_get(BMesh *bm, char htype) { - switch (htype) { - case BM_VERT: return &bm->vdata; - case BM_EDGE: return &bm->edata; - case BM_FACE: return &bm->pdata; - case BM_LOOP: return &bm->ldata; - } - - BLI_assert(0); - return NULL; + switch (htype) { + case BM_VERT: + return &bm->vdata; + case BM_EDGE: + return &bm->edata; + case BM_FACE: + return &bm->pdata; + case BM_LOOP: + return &bm->ldata; + } + + BLI_assert(0); + return NULL; } static CustomDataLayer *bpy_bmlayeritem_get(BPy_BMLayerItem *self) { - CustomData *data = bpy_bm_customdata_get(self->bm, self->htype); - const int index_absolute = CustomData_get_layer_index_n(data, self->type, self->index); - if (index_absolute != -1) { - return &data->layers[index_absolute]; - } - else { - PyErr_SetString(PyExc_RuntimeError, - "layer has become invalid"); - return NULL; - } + CustomData *data = bpy_bm_customdata_get(self->bm, self->htype); + const int index_absolute = CustomData_get_layer_index_n(data, self->type, self->index); + if (index_absolute != -1) { + return &data->layers[index_absolute]; + } + else { + PyErr_SetString(PyExc_RuntimeError, "layer has become invalid"); + return NULL; + } } /* py-type definitions @@ -79,180 +82,273 @@ static CustomDataLayer *bpy_bmlayeritem_get(BPy_BMLayerItem *self) /* used for many different types */ PyDoc_STRVAR(bpy_bmlayeraccess_collection__float_doc, -"Generic float custom-data layer.\n\ntype: :class:`BMLayerCollection`" -); + "Generic float custom-data layer.\n\ntype: :class:`BMLayerCollection`"); PyDoc_STRVAR(bpy_bmlayeraccess_collection__int_doc, -"Generic int custom-data layer.\n\ntype: :class:`BMLayerCollection`" -); + "Generic int custom-data layer.\n\ntype: :class:`BMLayerCollection`"); PyDoc_STRVAR(bpy_bmlayeraccess_collection__string_doc, -"Generic string custom-data layer (exposed as bytes, 255 max length).\n\ntype: :class:`BMLayerCollection`" -); + "Generic string custom-data layer (exposed as bytes, 255 max length).\n\ntype: " + ":class:`BMLayerCollection`"); PyDoc_STRVAR(bpy_bmlayeraccess_collection__deform_doc, -"Vertex deform weight :class:`BMDeformVert` (TODO).\n\ntype: :class:`BMLayerCollection`" // TYPE DOESN'T EXIST YET -); -PyDoc_STRVAR(bpy_bmlayeraccess_collection__shape_doc, -"Vertex shapekey absolute location (as a 3D Vector).\n\n:type: :class:`BMLayerCollection`" + "Vertex deform weight :class:`BMDeformVert` (TODO).\n\ntype: " + ":class:`BMLayerCollection`" // TYPE DOESN'T EXIST YET ); +PyDoc_STRVAR( + bpy_bmlayeraccess_collection__shape_doc, + "Vertex shapekey absolute location (as a 3D Vector).\n\n:type: :class:`BMLayerCollection`"); PyDoc_STRVAR(bpy_bmlayeraccess_collection__bevel_weight_doc, -"Bevel weight float in [0 - 1].\n\n:type: :class:`BMLayerCollection`" -); + "Bevel weight float in [0 - 1].\n\n:type: :class:`BMLayerCollection`"); PyDoc_STRVAR(bpy_bmlayeraccess_collection__crease_doc, -"Edge crease for subsurf - float in [0 - 1].\n\n:type: :class:`BMLayerCollection`" -); -PyDoc_STRVAR(bpy_bmlayeraccess_collection__uv_doc, -"Accessor for :class:`BMLoopUV` UV (as a 2D Vector).\n\ntype: :class:`BMLayerCollection`" -); + "Edge crease for subsurf - float in [0 - 1].\n\n:type: :class:`BMLayerCollection`"); +PyDoc_STRVAR( + bpy_bmlayeraccess_collection__uv_doc, + "Accessor for :class:`BMLoopUV` UV (as a 2D Vector).\n\ntype: :class:`BMLayerCollection`"); PyDoc_STRVAR(bpy_bmlayeraccess_collection__color_doc, -"Accessor for vertex color layer.\n\ntype: :class:`BMLayerCollection`" -); + "Accessor for vertex color layer.\n\ntype: :class:`BMLayerCollection`"); PyDoc_STRVAR(bpy_bmlayeraccess_collection__skin_doc, -"Accessor for skin layer.\n\ntype: :class:`BMLayerCollection`" -); + "Accessor for skin layer.\n\ntype: :class:`BMLayerCollection`"); PyDoc_STRVAR(bpy_bmlayeraccess_collection__paint_mask_doc, -"Accessor for paint mask layer.\n\ntype: :class:`BMLayerCollection`" -); + "Accessor for paint mask layer.\n\ntype: :class:`BMLayerCollection`"); PyDoc_STRVAR(bpy_bmlayeraccess_collection__face_map_doc, -"FaceMap custom-data layer.\n\ntype: :class:`BMLayerCollection`" -); + "FaceMap custom-data layer.\n\ntype: :class:`BMLayerCollection`"); #ifdef WITH_FREESTYLE PyDoc_STRVAR(bpy_bmlayeraccess_collection__freestyle_edge_doc, -"Accessor for Freestyle edge layer.\n\ntype: :class:`BMLayerCollection`" -); + "Accessor for Freestyle edge layer.\n\ntype: :class:`BMLayerCollection`"); PyDoc_STRVAR(bpy_bmlayeraccess_collection__freestyle_face_doc, -"Accessor for Freestyle face layer.\n\ntype: :class:`BMLayerCollection`" -); + "Accessor for Freestyle face layer.\n\ntype: :class:`BMLayerCollection`"); #endif static PyObject *bpy_bmlayeraccess_collection_get(BPy_BMLayerAccess *self, void *flag) { - const int type = (int)POINTER_AS_INT(flag); + const int type = (int)POINTER_AS_INT(flag); - BPY_BM_CHECK_OBJ(self); + BPY_BM_CHECK_OBJ(self); - return BPy_BMLayerCollection_CreatePyObject(self->bm, self->htype, type); + return BPy_BMLayerCollection_CreatePyObject(self->bm, self->htype, type); } - PyDoc_STRVAR(bpy_bmlayercollection_active_doc, -"The active layer of this type (read-only).\n\n:type: :class:`BMLayerItem`" -); + "The active layer of this type (read-only).\n\n:type: :class:`BMLayerItem`"); static PyObject *bpy_bmlayercollection_active_get(BPy_BMLayerItem *self, void *UNUSED(flag)) { - CustomData *data; - int index; + CustomData *data; + int index; - BPY_BM_CHECK_OBJ(self); + BPY_BM_CHECK_OBJ(self); - data = bpy_bm_customdata_get(self->bm, self->htype); - index = CustomData_get_active_layer(data, self->type); /* type relative */ + data = bpy_bm_customdata_get(self->bm, self->htype); + index = CustomData_get_active_layer(data, self->type); /* type relative */ - if (index != -1) { - return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index); - } - else { - Py_RETURN_NONE; - } + if (index != -1) { + return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index); + } + else { + Py_RETURN_NONE; + } } - -PyDoc_STRVAR(bpy_bmlayercollection_is_singleton_doc, -"True if there can exists only one layer of this type (read-only).\n\n:type: boolean" -); +PyDoc_STRVAR( + bpy_bmlayercollection_is_singleton_doc, + "True if there can exists only one layer of this type (read-only).\n\n:type: boolean"); static PyObject *bpy_bmlayercollection_is_singleton_get(BPy_BMLayerItem *self, void *UNUSED(flag)) { - BPY_BM_CHECK_OBJ(self); + BPY_BM_CHECK_OBJ(self); - return PyBool_FromLong(CustomData_layertype_is_singleton(self->type)); + return PyBool_FromLong(CustomData_layertype_is_singleton(self->type)); } PyDoc_STRVAR(bpy_bmlayercollection_name_doc, -"The layers unique name (read-only).\n\n:type: string" -); + "The layers unique name (read-only).\n\n:type: string"); static PyObject *bpy_bmlayeritem_name_get(BPy_BMLayerItem *self, void *UNUSED(flag)) { - CustomDataLayer *layer; + CustomDataLayer *layer; - BPY_BM_CHECK_OBJ(self); + BPY_BM_CHECK_OBJ(self); - layer = bpy_bmlayeritem_get(self); - if (layer) { - return PyUnicode_FromString(layer->name); - } - else { - return NULL; - } + layer = bpy_bmlayeritem_get(self); + if (layer) { + return PyUnicode_FromString(layer->name); + } + else { + return NULL; + } } static PyGetSetDef bpy_bmlayeraccess_vert_getseters[] = { - {(char *)"deform", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__deform_doc, (void *)CD_MDEFORMVERT}, - - {(char *)"float", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__float_doc, (void *)CD_PROP_FLT}, - {(char *)"int", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__int_doc, (void *)CD_PROP_INT}, - {(char *)"string", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__string_doc, (void *)CD_PROP_STR}, - - {(char *)"shape", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__shape_doc, (void *)CD_SHAPEKEY}, - {(char *)"bevel_weight", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__bevel_weight_doc, (void *)CD_BWEIGHT}, - {(char *)"skin", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__skin_doc, (void *)CD_MVERT_SKIN}, - {(char *)"paint_mask", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__paint_mask_doc, (void *)CD_PAINT_MASK}, - - {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ + {(char *)"deform", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__deform_doc, + (void *)CD_MDEFORMVERT}, + + {(char *)"float", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__float_doc, + (void *)CD_PROP_FLT}, + {(char *)"int", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__int_doc, + (void *)CD_PROP_INT}, + {(char *)"string", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__string_doc, + (void *)CD_PROP_STR}, + + {(char *)"shape", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__shape_doc, + (void *)CD_SHAPEKEY}, + {(char *)"bevel_weight", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__bevel_weight_doc, + (void *)CD_BWEIGHT}, + {(char *)"skin", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__skin_doc, + (void *)CD_MVERT_SKIN}, + {(char *)"paint_mask", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__paint_mask_doc, + (void *)CD_PAINT_MASK}, + + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; static PyGetSetDef bpy_bmlayeraccess_edge_getseters[] = { - {(char *)"float", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__float_doc, (void *)CD_PROP_FLT}, - {(char *)"int", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__int_doc, (void *)CD_PROP_INT}, - {(char *)"string", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__string_doc, (void *)CD_PROP_STR}, - - {(char *)"bevel_weight", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__bevel_weight_doc, (void *)CD_BWEIGHT}, - {(char *)"crease", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__crease_doc, (void *)CD_CREASE}, + {(char *)"float", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__float_doc, + (void *)CD_PROP_FLT}, + {(char *)"int", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__int_doc, + (void *)CD_PROP_INT}, + {(char *)"string", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__string_doc, + (void *)CD_PROP_STR}, + + {(char *)"bevel_weight", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__bevel_weight_doc, + (void *)CD_BWEIGHT}, + {(char *)"crease", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__crease_doc, + (void *)CD_CREASE}, #ifdef WITH_FREESTYLE - {(char *)"freestyle", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__freestyle_edge_doc, (void *)CD_FREESTYLE_EDGE}, + {(char *)"freestyle", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__freestyle_edge_doc, + (void *)CD_FREESTYLE_EDGE}, #endif - {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; static PyGetSetDef bpy_bmlayeraccess_face_getseters[] = { - {(char *)"float", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__float_doc, (void *)CD_PROP_FLT}, - {(char *)"int", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__int_doc, (void *)CD_PROP_INT}, - {(char *)"string", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__string_doc, (void *)CD_PROP_STR}, - {(char *)"face_map", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__face_map_doc, (void *)CD_FACEMAP}, + {(char *)"float", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__float_doc, + (void *)CD_PROP_FLT}, + {(char *)"int", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__int_doc, + (void *)CD_PROP_INT}, + {(char *)"string", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__string_doc, + (void *)CD_PROP_STR}, + {(char *)"face_map", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__face_map_doc, + (void *)CD_FACEMAP}, #ifdef WITH_FREESTYLE - {(char *)"freestyle", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__freestyle_face_doc, (void *)CD_FREESTYLE_FACE}, + {(char *)"freestyle", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__freestyle_face_doc, + (void *)CD_FREESTYLE_FACE}, #endif - {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; static PyGetSetDef bpy_bmlayeraccess_loop_getseters[] = { - {(char *)"float", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__float_doc, (void *)CD_PROP_FLT}, - {(char *)"int", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__int_doc, (void *)CD_PROP_INT}, - {(char *)"string", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__string_doc, (void *)CD_PROP_STR}, - - {(char *)"uv", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__uv_doc, (void *)CD_MLOOPUV}, - {(char *)"color", (getter)bpy_bmlayeraccess_collection_get, (setter)NULL, (char *)bpy_bmlayeraccess_collection__color_doc, (void *)CD_MLOOPCOL}, - - {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ + {(char *)"float", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__float_doc, + (void *)CD_PROP_FLT}, + {(char *)"int", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__int_doc, + (void *)CD_PROP_INT}, + {(char *)"string", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__string_doc, + (void *)CD_PROP_STR}, + + {(char *)"uv", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__uv_doc, + (void *)CD_MLOOPUV}, + {(char *)"color", + (getter)bpy_bmlayeraccess_collection_get, + (setter)NULL, + (char *)bpy_bmlayeraccess_collection__color_doc, + (void *)CD_MLOOPCOL}, + + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; - static PyGetSetDef bpy_bmlayercollection_getseters[] = { - /* BMESH_TODO, make writeable */ - {(char *)"active", (getter)bpy_bmlayercollection_active_get, (setter)NULL, (char *)bpy_bmlayercollection_active_doc, NULL}, - {(char *)"is_singleton", (getter)bpy_bmlayercollection_is_singleton_get, (setter)NULL, (char *)bpy_bmlayercollection_is_singleton_doc, NULL}, - - {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ + /* BMESH_TODO, make writeable */ + {(char *)"active", + (getter)bpy_bmlayercollection_active_get, + (setter)NULL, + (char *)bpy_bmlayercollection_active_doc, + NULL}, + {(char *)"is_singleton", + (getter)bpy_bmlayercollection_is_singleton_get, + (setter)NULL, + (char *)bpy_bmlayercollection_is_singleton_doc, + NULL}, + + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; static PyGetSetDef bpy_bmlayeritem_getseters[] = { - /* BMESH_TODO, make writeable */ - {(char *)"name", (getter)bpy_bmlayeritem_name_get, (setter)NULL, (char *)bpy_bmlayercollection_name_doc, NULL}, - - {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ + /* BMESH_TODO, make writeable */ + {(char *)"name", + (getter)bpy_bmlayeritem_name_get, + (setter)NULL, + (char *)bpy_bmlayercollection_name_doc, + NULL}, + + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; - /* Methods * ======= */ @@ -260,318 +356,310 @@ static PyGetSetDef bpy_bmlayeritem_getseters[] = { * ----------------- */ PyDoc_STRVAR(bpy_bmlayeritem_copy_from_doc, -".. method:: copy_from(other)\n" -"\n" -" Return a copy of the layer\n" -"\n" -" :arg other: Another layer to copy from.\n" -" :arg other: :class:`BMLayerItem`\n" -); + ".. method:: copy_from(other)\n" + "\n" + " Return a copy of the layer\n" + "\n" + " :arg other: Another layer to copy from.\n" + " :arg other: :class:`BMLayerItem`\n"); static PyObject *bpy_bmlayeritem_copy_from(BPy_BMLayerItem *self, BPy_BMLayerItem *value) { - CustomData *data; + CustomData *data; - if (!BPy_BMLayerItem_Check(value)) { - PyErr_Format(PyExc_TypeError, - "layer.copy_from(x): expected BMLayerItem, not '%.200s'", - Py_TYPE(value)->tp_name); - return NULL; - } + if (!BPy_BMLayerItem_Check(value)) { + PyErr_Format(PyExc_TypeError, + "layer.copy_from(x): expected BMLayerItem, not '%.200s'", + Py_TYPE(value)->tp_name); + return NULL; + } - BPY_BM_CHECK_OBJ(self); - BPY_BM_CHECK_SOURCE_OBJ(self->bm, "layer.copy_from()", value); + BPY_BM_CHECK_OBJ(self); + BPY_BM_CHECK_SOURCE_OBJ(self->bm, "layer.copy_from()", value); - if ((self->htype != value->htype) || - (self->type != value->type)) - { - PyErr_SetString(PyExc_ValueError, - "layer.copy_from(other): layer type mismatch"); - } + if ((self->htype != value->htype) || (self->type != value->type)) { + PyErr_SetString(PyExc_ValueError, "layer.copy_from(other): layer type mismatch"); + } - else if (self->index == value->index) { - Py_RETURN_NONE; - } + else if (self->index == value->index) { + Py_RETURN_NONE; + } - data = bpy_bm_customdata_get(self->bm, self->htype); + data = bpy_bm_customdata_get(self->bm, self->htype); - if ((bpy_bmlayeritem_get(self) == NULL) || - (bpy_bmlayeritem_get(value) == NULL)) - { - return NULL; - } + if ((bpy_bmlayeritem_get(self) == NULL) || (bpy_bmlayeritem_get(value) == NULL)) { + return NULL; + } - BM_data_layer_copy(self->bm, data, self->type, value->index, self->index); + BM_data_layer_copy(self->bm, data, self->type, value->index, self->index); - Py_RETURN_NONE; + Py_RETURN_NONE; } /* similar to new(), but no name arg. */ PyDoc_STRVAR(bpy_bmlayercollection_verify_doc, -".. method:: verify()\n" -"\n" -" Create a new layer or return an existing active layer\n" -"\n" -" :return: The newly verified layer.\n" -" :rtype: :class:`BMLayerItem`\n" -); + ".. method:: verify()\n" + "\n" + " Create a new layer or return an existing active layer\n" + "\n" + " :return: The newly verified layer.\n" + " :rtype: :class:`BMLayerItem`\n"); static PyObject *bpy_bmlayercollection_verify(BPy_BMLayerCollection *self) { - int index; - CustomData *data; + int index; + CustomData *data; - BPY_BM_CHECK_OBJ(self); + BPY_BM_CHECK_OBJ(self); - data = bpy_bm_customdata_get(self->bm, self->htype); + data = bpy_bm_customdata_get(self->bm, self->htype); - index = CustomData_get_active_layer(data, self->type); /* type relative */ + index = CustomData_get_active_layer(data, self->type); /* type relative */ - if (index == -1) { - BM_data_layer_add(self->bm, data, self->type); - index = 0; - } + if (index == -1) { + BM_data_layer_add(self->bm, data, self->type); + index = 0; + } - BLI_assert(index >= 0); + BLI_assert(index >= 0); - return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index); + return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index); } PyDoc_STRVAR(bpy_bmlayercollection_new_doc, -".. method:: new(name)\n" -"\n" -" Create a new layer\n" -"\n" -" :arg name: Optional name argument (will be made unique).\n" -" :type name: string\n" -" :return: The newly created layer.\n" -" :rtype: :class:`BMLayerItem`\n" -); + ".. method:: new(name)\n" + "\n" + " Create a new layer\n" + "\n" + " :arg name: Optional name argument (will be made unique).\n" + " :type name: string\n" + " :return: The newly created layer.\n" + " :rtype: :class:`BMLayerItem`\n"); static PyObject *bpy_bmlayercollection_new(BPy_BMLayerCollection *self, PyObject *args) { - const char *name = NULL; - int index; - CustomData *data; + const char *name = NULL; + int index; + CustomData *data; - BPY_BM_CHECK_OBJ(self); + BPY_BM_CHECK_OBJ(self); - if (!PyArg_ParseTuple(args, "|s:new", &name)) { - return NULL; - } + if (!PyArg_ParseTuple(args, "|s:new", &name)) { + return NULL; + } - data = bpy_bm_customdata_get(self->bm, self->htype); + data = bpy_bm_customdata_get(self->bm, self->htype); - if (CustomData_layertype_is_singleton(self->type) && - CustomData_has_layer(data, self->type)) - { - PyErr_SetString(PyExc_ValueError, - "layers.new(): is a singleton, use verify() instead"); - return NULL; - } + if (CustomData_layertype_is_singleton(self->type) && CustomData_has_layer(data, self->type)) { + PyErr_SetString(PyExc_ValueError, "layers.new(): is a singleton, use verify() instead"); + return NULL; + } - if (name) { - BM_data_layer_add_named(self->bm, data, self->type, name); - } - else { - BM_data_layer_add(self->bm, data, self->type); - } + if (name) { + BM_data_layer_add_named(self->bm, data, self->type, name); + } + else { + BM_data_layer_add(self->bm, data, self->type); + } - index = CustomData_number_of_layers(data, self->type) - 1; - BLI_assert(index >= 0); + index = CustomData_number_of_layers(data, self->type) - 1; + BLI_assert(index >= 0); - return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index); + return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index); } PyDoc_STRVAR(bpy_bmlayercollection_remove_doc, -".. method:: remove(layer)\n" -"\n" -" Remove a layer\n" -"\n" -" :arg layer: The layer to remove.\n" -" :type layer: :class:`BMLayerItem`\n" -); + ".. method:: remove(layer)\n" + "\n" + " Remove a layer\n" + "\n" + " :arg layer: The layer to remove.\n" + " :type layer: :class:`BMLayerItem`\n"); static PyObject *bpy_bmlayercollection_remove(BPy_BMLayerCollection *self, BPy_BMLayerItem *value) { - CustomData *data; + CustomData *data; - BPY_BM_CHECK_OBJ(self); + BPY_BM_CHECK_OBJ(self); - if (!BPy_BMLayerItem_Check(value)) { - PyErr_Format(PyExc_TypeError, - "layers.remove(x): expected BMLayerItem, not '%.200s'", - Py_TYPE(value)->tp_name); - return NULL; - } + if (!BPy_BMLayerItem_Check(value)) { + PyErr_Format(PyExc_TypeError, + "layers.remove(x): expected BMLayerItem, not '%.200s'", + Py_TYPE(value)->tp_name); + return NULL; + } - BPY_BM_CHECK_OBJ(value); + BPY_BM_CHECK_OBJ(value); - if ((self->bm != value->bm) || - (self->type != value->type) || - (self->htype != value->htype)) - { - PyErr_SetString(PyExc_ValueError, - "layers.remove(x): x not in layers"); - } + if ((self->bm != value->bm) || (self->type != value->type) || (self->htype != value->htype)) { + PyErr_SetString(PyExc_ValueError, "layers.remove(x): x not in layers"); + } - data = bpy_bm_customdata_get(self->bm, self->htype); - BM_data_layer_free_n(self->bm, data, self->type, value->index); + data = bpy_bm_customdata_get(self->bm, self->htype); + BM_data_layer_free_n(self->bm, data, self->type, value->index); - Py_RETURN_NONE; + Py_RETURN_NONE; } - PyDoc_STRVAR(bpy_bmlayercollection_keys_doc, -".. method:: keys()\n" -"\n" -" Return the identifiers of collection members\n" -" (matching pythons dict.keys() functionality).\n" -"\n" -" :return: the identifiers for each member of this collection.\n" -" :rtype: list of strings\n" -); + ".. method:: keys()\n" + "\n" + " Return the identifiers of collection members\n" + " (matching pythons dict.keys() functionality).\n" + "\n" + " :return: the identifiers for each member of this collection.\n" + " :rtype: list of strings\n"); static PyObject *bpy_bmlayercollection_keys(BPy_BMLayerCollection *self) { - PyObject *ret; - PyObject *item; - int index; - CustomData *data; - int tot, i; + PyObject *ret; + PyObject *item; + int index; + CustomData *data; + int tot, i; - BPY_BM_CHECK_OBJ(self); + BPY_BM_CHECK_OBJ(self); - data = bpy_bm_customdata_get(self->bm, self->htype); - index = CustomData_get_layer_index(data, self->type); /* absolute, but no need to make relative */ - tot = (index != -1) ? CustomData_number_of_layers(data, self->type) : 0; + data = bpy_bm_customdata_get(self->bm, self->htype); + index = CustomData_get_layer_index(data, + self->type); /* absolute, but no need to make relative */ + tot = (index != -1) ? CustomData_number_of_layers(data, self->type) : 0; - ret = PyList_New(tot); + ret = PyList_New(tot); - for (i = 0; tot-- > 0; index++) { - item = PyUnicode_FromString(data->layers[index].name); - PyList_SET_ITEM(ret, i++, item); - } + for (i = 0; tot-- > 0; index++) { + item = PyUnicode_FromString(data->layers[index].name); + PyList_SET_ITEM(ret, i++, item); + } - return ret; + return ret; } PyDoc_STRVAR(bpy_bmlayercollection_items_doc, -".. method:: items()\n" -"\n" -" Return the identifiers of collection members\n" -" (matching pythons dict.items() functionality).\n" -"\n" -" :return: (key, value) pairs for each member of this collection.\n" -" :rtype: list of tuples\n" -); + ".. method:: items()\n" + "\n" + " Return the identifiers of collection members\n" + " (matching pythons dict.items() functionality).\n" + "\n" + " :return: (key, value) pairs for each member of this collection.\n" + " :rtype: list of tuples\n"); static PyObject *bpy_bmlayercollection_items(BPy_BMLayerCollection *self) { - PyObject *ret; - PyObject *item; - int index; - CustomData *data; - int tot, i; + PyObject *ret; + PyObject *item; + int index; + CustomData *data; + int tot, i; - BPY_BM_CHECK_OBJ(self); + BPY_BM_CHECK_OBJ(self); - data = bpy_bm_customdata_get(self->bm, self->htype); - index = CustomData_get_layer_index(data, self->type); - tot = (index != -1) ? CustomData_number_of_layers(data, self->type) : 0; + data = bpy_bm_customdata_get(self->bm, self->htype); + index = CustomData_get_layer_index(data, self->type); + tot = (index != -1) ? CustomData_number_of_layers(data, self->type) : 0; - ret = PyList_New(tot); + ret = PyList_New(tot); - for (i = 0; tot-- > 0; index++) { - item = PyTuple_New(2); - PyTuple_SET_ITEMS(item, - PyUnicode_FromString(data->layers[index].name), - BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, i)); - PyList_SET_ITEM(ret, i++, item); - } + for (i = 0; tot-- > 0; index++) { + item = PyTuple_New(2); + PyTuple_SET_ITEMS(item, + PyUnicode_FromString(data->layers[index].name), + BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, i)); + PyList_SET_ITEM(ret, i++, item); + } - return ret; + return ret; } PyDoc_STRVAR(bpy_bmlayercollection_values_doc, -".. method:: values()\n" -"\n" -" Return the values of collection\n" -" (matching pythons dict.values() functionality).\n" -"\n" -" :return: the members of this collection.\n" -" :rtype: list\n" -); + ".. method:: values()\n" + "\n" + " Return the values of collection\n" + " (matching pythons dict.values() functionality).\n" + "\n" + " :return: the members of this collection.\n" + " :rtype: list\n"); static PyObject *bpy_bmlayercollection_values(BPy_BMLayerCollection *self) { - PyObject *ret; - PyObject *item; - int index; - CustomData *data; - int tot, i; + PyObject *ret; + PyObject *item; + int index; + CustomData *data; + int tot, i; - BPY_BM_CHECK_OBJ(self); + BPY_BM_CHECK_OBJ(self); - data = bpy_bm_customdata_get(self->bm, self->htype); - index = CustomData_get_layer_index(data, self->type); - tot = (index != -1) ? CustomData_number_of_layers(data, self->type) : 0; + data = bpy_bm_customdata_get(self->bm, self->htype); + index = CustomData_get_layer_index(data, self->type); + tot = (index != -1) ? CustomData_number_of_layers(data, self->type) : 0; - ret = PyList_New(tot); + ret = PyList_New(tot); - for (i = 0; tot-- > 0; index++) { - item = BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, i); - PyList_SET_ITEM(ret, i++, item); - } + for (i = 0; tot-- > 0; index++) { + item = BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, i); + PyList_SET_ITEM(ret, i++, item); + } - return ret; + return ret; } PyDoc_STRVAR(bpy_bmlayercollection_get_doc, -".. method:: get(key, default=None)\n" -"\n" -" Returns the value of the layer matching the key or default\n" -" when not found (matches pythons dictionary function of the same name).\n" -"\n" -" :arg key: The key associated with the layer.\n" -" :type key: string\n" -" :arg default: Optional argument for the value to return if\n" -" *key* is not found.\n" -" :type default: Undefined\n" -); + ".. method:: get(key, default=None)\n" + "\n" + " Returns the value of the layer matching the key or default\n" + " when not found (matches pythons dictionary function of the same name).\n" + "\n" + " :arg key: The key associated with the layer.\n" + " :type key: string\n" + " :arg default: Optional argument for the value to return if\n" + " *key* is not found.\n" + " :type default: Undefined\n"); static PyObject *bpy_bmlayercollection_get(BPy_BMLayerCollection *self, PyObject *args) { - const char *key; - PyObject *def = Py_None; + const char *key; + PyObject *def = Py_None; - BPY_BM_CHECK_OBJ(self); + BPY_BM_CHECK_OBJ(self); - if (!PyArg_ParseTuple(args, "s|O:get", &key, &def)) { - return NULL; - } - else { - CustomData *data; - int index; + if (!PyArg_ParseTuple(args, "s|O:get", &key, &def)) { + return NULL; + } + else { + CustomData *data; + int index; - data = bpy_bm_customdata_get(self->bm, self->htype); - index = CustomData_get_named_layer(data, self->type, key); /* type relative */ + data = bpy_bm_customdata_get(self->bm, self->htype); + index = CustomData_get_named_layer(data, self->type, key); /* type relative */ - if (index != -1) { - return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index); - } - } + if (index != -1) { + return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index); + } + } - return Py_INCREF_RET(def); + return Py_INCREF_RET(def); } static struct PyMethodDef bpy_bmlayeritem_methods[] = { - {"copy_from", (PyCFunction)bpy_bmlayeritem_copy_from, METH_O, bpy_bmlayeritem_copy_from_doc}, - {NULL, NULL, 0, NULL}, + {"copy_from", (PyCFunction)bpy_bmlayeritem_copy_from, METH_O, bpy_bmlayeritem_copy_from_doc}, + {NULL, NULL, 0, NULL}, }; static struct PyMethodDef bpy_bmelemseq_methods[] = { - {"verify", (PyCFunction)bpy_bmlayercollection_verify, METH_NOARGS, bpy_bmlayercollection_verify_doc}, - {"new", (PyCFunction)bpy_bmlayercollection_new, METH_VARARGS, bpy_bmlayercollection_new_doc}, - {"remove", (PyCFunction)bpy_bmlayercollection_remove, METH_O, bpy_bmlayercollection_remove_doc}, - - {"keys", (PyCFunction)bpy_bmlayercollection_keys, METH_NOARGS, bpy_bmlayercollection_keys_doc}, - {"values", (PyCFunction)bpy_bmlayercollection_values, METH_NOARGS, bpy_bmlayercollection_values_doc}, - {"items", (PyCFunction)bpy_bmlayercollection_items, METH_NOARGS, bpy_bmlayercollection_items_doc}, - {"get", (PyCFunction)bpy_bmlayercollection_get, METH_VARARGS, bpy_bmlayercollection_get_doc}, - {NULL, NULL, 0, NULL}, + {"verify", + (PyCFunction)bpy_bmlayercollection_verify, + METH_NOARGS, + bpy_bmlayercollection_verify_doc}, + {"new", (PyCFunction)bpy_bmlayercollection_new, METH_VARARGS, bpy_bmlayercollection_new_doc}, + {"remove", + (PyCFunction)bpy_bmlayercollection_remove, + METH_O, + bpy_bmlayercollection_remove_doc}, + + {"keys", (PyCFunction)bpy_bmlayercollection_keys, METH_NOARGS, bpy_bmlayercollection_keys_doc}, + {"values", + (PyCFunction)bpy_bmlayercollection_values, + METH_NOARGS, + bpy_bmlayercollection_values_doc}, + {"items", + (PyCFunction)bpy_bmlayercollection_items, + METH_NOARGS, + bpy_bmlayercollection_items_doc}, + {"get", (PyCFunction)bpy_bmlayercollection_get, METH_VARARGS, bpy_bmlayercollection_get_doc}, + {NULL, NULL, 0, NULL}, }; /* Sequences @@ -579,183 +667,185 @@ static struct PyMethodDef bpy_bmelemseq_methods[] = { static Py_ssize_t bpy_bmlayercollection_length(BPy_BMLayerCollection *self) { - CustomData *data; + CustomData *data; - BPY_BM_CHECK_INT(self); + BPY_BM_CHECK_INT(self); - data = bpy_bm_customdata_get(self->bm, self->htype); + data = bpy_bm_customdata_get(self->bm, self->htype); - return CustomData_number_of_layers(data, self->type); + return CustomData_number_of_layers(data, self->type); } -static PyObject *bpy_bmlayercollection_subscript_str(BPy_BMLayerCollection *self, const char *keyname) +static PyObject *bpy_bmlayercollection_subscript_str(BPy_BMLayerCollection *self, + const char *keyname) { - CustomData *data; - int index; - - BPY_BM_CHECK_OBJ(self); - - data = bpy_bm_customdata_get(self->bm, self->htype); - index = CustomData_get_named_layer(data, self->type, keyname); /* type relative */ - - if (index != -1) { - return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index); - } - else { - PyErr_Format(PyExc_KeyError, - "BMLayerCollection[key]: key \"%.200s\" not found", keyname); - return NULL; - } + CustomData *data; + int index; + + BPY_BM_CHECK_OBJ(self); + + data = bpy_bm_customdata_get(self->bm, self->htype); + index = CustomData_get_named_layer(data, self->type, keyname); /* type relative */ + + if (index != -1) { + return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index); + } + else { + PyErr_Format(PyExc_KeyError, "BMLayerCollection[key]: key \"%.200s\" not found", keyname); + return NULL; + } } static PyObject *bpy_bmlayercollection_subscript_int(BPy_BMLayerCollection *self, int keynum) { - Py_ssize_t len; - BPY_BM_CHECK_OBJ(self); - - len = bpy_bmlayercollection_length(self); - - if (keynum < 0) { - keynum += len; - } - if (keynum >= 0) { - if (keynum < len) { - return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, keynum); - } - } - - PyErr_Format(PyExc_IndexError, - "BMLayerCollection[index]: index %d out of range", keynum); - return NULL; + Py_ssize_t len; + BPY_BM_CHECK_OBJ(self); + + len = bpy_bmlayercollection_length(self); + + if (keynum < 0) { + keynum += len; + } + if (keynum >= 0) { + if (keynum < len) { + return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, keynum); + } + } + + PyErr_Format(PyExc_IndexError, "BMLayerCollection[index]: index %d out of range", keynum); + return NULL; } -static PyObject *bpy_bmlayercollection_subscript_slice(BPy_BMLayerCollection *self, Py_ssize_t start, Py_ssize_t stop) +static PyObject *bpy_bmlayercollection_subscript_slice(BPy_BMLayerCollection *self, + Py_ssize_t start, + Py_ssize_t stop) { - Py_ssize_t len = bpy_bmlayercollection_length(self); - int count = 0; + Py_ssize_t len = bpy_bmlayercollection_length(self); + int count = 0; - PyObject *tuple; + PyObject *tuple; - BPY_BM_CHECK_OBJ(self); + BPY_BM_CHECK_OBJ(self); - if (start >= len) { - start = len - 1; - } - if (stop >= len) { - stop = len - 1; - } + if (start >= len) { + start = len - 1; + } + if (stop >= len) { + stop = len - 1; + } - tuple = PyTuple_New(stop - start); + tuple = PyTuple_New(stop - start); - for (count = start; count < stop; count++) { - PyTuple_SET_ITEM(tuple, count - start, BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, count)); - } + for (count = start; count < stop; count++) { + PyTuple_SET_ITEM(tuple, + count - start, + BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, count)); + } - return tuple; + return tuple; } static PyObject *bpy_bmlayercollection_subscript(BPy_BMLayerCollection *self, PyObject *key) { - /* don't need error check here */ - if (PyUnicode_Check(key)) { - return bpy_bmlayercollection_subscript_str(self, _PyUnicode_AsString(key)); - } - else if (PyIndex_Check(key)) { - Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) { - return NULL; - } - return bpy_bmlayercollection_subscript_int(self, i); - } - else if (PySlice_Check(key)) { - PySliceObject *key_slice = (PySliceObject *)key; - Py_ssize_t step = 1; - - if (key_slice->step != Py_None && !_PyEval_SliceIndex(key, &step)) { - return NULL; - } - else if (step != 1) { - PyErr_SetString(PyExc_TypeError, - "BMLayerCollection[slice]: slice steps not supported"); - return NULL; - } - else if (key_slice->start == Py_None && key_slice->stop == Py_None) { - return bpy_bmlayercollection_subscript_slice(self, 0, PY_SSIZE_T_MAX); - } - else { - Py_ssize_t start = 0, stop = PY_SSIZE_T_MAX; - - /* avoid PySlice_GetIndicesEx because it needs to know the length ahead of time. */ - if (key_slice->start != Py_None && !_PyEval_SliceIndex(key_slice->start, &start)) { - return NULL; - } - if (key_slice->stop != Py_None && !_PyEval_SliceIndex(key_slice->stop, &stop)) { - return NULL; - } - - if (start < 0 || stop < 0) { - /* only get the length for negative values */ - Py_ssize_t len = bpy_bmlayercollection_length(self); - if (start < 0) { - start += len; - } - if (stop < 0) { - stop += len; - } - } - - if (stop - start <= 0) { - return PyTuple_New(0); - } - else { - return bpy_bmlayercollection_subscript_slice(self, start, stop); - } - } - } - else { - PyErr_SetString(PyExc_AttributeError, - "BMLayerCollection[key]: invalid key, key must be an int"); - return NULL; - } + /* don't need error check here */ + if (PyUnicode_Check(key)) { + return bpy_bmlayercollection_subscript_str(self, _PyUnicode_AsString(key)); + } + else if (PyIndex_Check(key)) { + Py_ssize_t i = PyNumber_AsSsize_t(key, PyExc_IndexError); + if (i == -1 && PyErr_Occurred()) { + return NULL; + } + return bpy_bmlayercollection_subscript_int(self, i); + } + else if (PySlice_Check(key)) { + PySliceObject *key_slice = (PySliceObject *)key; + Py_ssize_t step = 1; + + if (key_slice->step != Py_None && !_PyEval_SliceIndex(key, &step)) { + return NULL; + } + else if (step != 1) { + PyErr_SetString(PyExc_TypeError, "BMLayerCollection[slice]: slice steps not supported"); + return NULL; + } + else if (key_slice->start == Py_None && key_slice->stop == Py_None) { + return bpy_bmlayercollection_subscript_slice(self, 0, PY_SSIZE_T_MAX); + } + else { + Py_ssize_t start = 0, stop = PY_SSIZE_T_MAX; + + /* avoid PySlice_GetIndicesEx because it needs to know the length ahead of time. */ + if (key_slice->start != Py_None && !_PyEval_SliceIndex(key_slice->start, &start)) { + return NULL; + } + if (key_slice->stop != Py_None && !_PyEval_SliceIndex(key_slice->stop, &stop)) { + return NULL; + } + + if (start < 0 || stop < 0) { + /* only get the length for negative values */ + Py_ssize_t len = bpy_bmlayercollection_length(self); + if (start < 0) { + start += len; + } + if (stop < 0) { + stop += len; + } + } + + if (stop - start <= 0) { + return PyTuple_New(0); + } + else { + return bpy_bmlayercollection_subscript_slice(self, start, stop); + } + } + } + else { + PyErr_SetString(PyExc_AttributeError, + "BMLayerCollection[key]: invalid key, key must be an int"); + return NULL; + } } static int bpy_bmlayercollection_contains(BPy_BMLayerCollection *self, PyObject *value) { - const char *keyname = _PyUnicode_AsString(value); - CustomData *data; - int index; + const char *keyname = _PyUnicode_AsString(value); + CustomData *data; + int index; - BPY_BM_CHECK_INT(self); + BPY_BM_CHECK_INT(self); - if (keyname == NULL) { - PyErr_SetString(PyExc_TypeError, - "BMLayerCollection.__contains__: expected a string"); - return -1; - } + if (keyname == NULL) { + PyErr_SetString(PyExc_TypeError, "BMLayerCollection.__contains__: expected a string"); + return -1; + } - data = bpy_bm_customdata_get(self->bm, self->htype); - index = CustomData_get_named_layer_index(data, self->type, keyname); + data = bpy_bm_customdata_get(self->bm, self->htype); + index = CustomData_get_named_layer_index(data, self->type, keyname); - return (index != -1) ? 1 : 0; + return (index != -1) ? 1 : 0; } static PySequenceMethods bpy_bmlayercollection_as_sequence = { - (lenfunc)bpy_bmlayercollection_length, /* sq_length */ - NULL, /* sq_concat */ - NULL, /* sq_repeat */ - (ssizeargfunc)bpy_bmlayercollection_subscript_int, /* sq_item */ /* Only set this so PySequence_Check() returns True */ - NULL, /* sq_slice */ - (ssizeobjargproc)NULL, /* sq_ass_item */ - NULL, /* *was* sq_ass_slice */ - (objobjproc)bpy_bmlayercollection_contains, /* sq_contains */ - (binaryfunc) NULL, /* sq_inplace_concat */ - (ssizeargfunc) NULL, /* sq_inplace_repeat */ + (lenfunc)bpy_bmlayercollection_length, /* sq_length */ + NULL, /* sq_concat */ + NULL, /* sq_repeat */ + (ssizeargfunc)bpy_bmlayercollection_subscript_int, + /* sq_item */ /* Only set this so PySequence_Check() returns True */ + NULL, /* sq_slice */ + (ssizeobjargproc)NULL, /* sq_ass_item */ + NULL, /* *was* sq_ass_slice */ + (objobjproc)bpy_bmlayercollection_contains, /* sq_contains */ + (binaryfunc)NULL, /* sq_inplace_concat */ + (ssizeargfunc)NULL, /* sq_inplace_repeat */ }; static PyMappingMethods bpy_bmlayercollection_as_mapping = { - (lenfunc)bpy_bmlayercollection_length, /* mp_length */ - (binaryfunc)bpy_bmlayercollection_subscript, /* mp_subscript */ - (objobjargproc)NULL, /* mp_ass_subscript */ + (lenfunc)bpy_bmlayercollection_length, /* mp_length */ + (binaryfunc)bpy_bmlayercollection_subscript, /* mp_subscript */ + (objobjargproc)NULL, /* mp_ass_subscript */ }; /* Iterator @@ -763,36 +853,33 @@ static PyMappingMethods bpy_bmlayercollection_as_mapping = { static PyObject *bpy_bmlayercollection_iter(BPy_BMLayerCollection *self) { - /* fake it with a list iterator */ - PyObject *ret; - PyObject *iter = NULL; + /* fake it with a list iterator */ + PyObject *ret; + PyObject *iter = NULL; - BPY_BM_CHECK_OBJ(self); + BPY_BM_CHECK_OBJ(self); - ret = bpy_bmlayercollection_subscript_slice(self, 0, PY_SSIZE_T_MIN); + ret = bpy_bmlayercollection_subscript_slice(self, 0, PY_SSIZE_T_MIN); - if (ret) { - iter = PyObject_GetIter(ret); - Py_DECREF(ret); - } + if (ret) { + iter = PyObject_GetIter(ret); + Py_DECREF(ret); + } - return iter; + return iter; } -PyDoc_STRVAR(bpy_bmlayeraccess_type_doc, -"Exposes custom-data layer attributes." -); +PyDoc_STRVAR(bpy_bmlayeraccess_type_doc, "Exposes custom-data layer attributes."); PyDoc_STRVAR(bpy_bmlayercollection_type_doc, -"Gives access to a collection of custom-data layers of the same type and behaves like python dictionaries, " -"except for the ability to do list like index access." -); + "Gives access to a collection of custom-data layers of the same type and behaves " + "like python dictionaries, " + "except for the ability to do list like index access."); PyDoc_STRVAR(bpy_bmlayeritem_type_doc, -"Exposes a single custom data layer, " -"their main purpose is for use as item accessors to custom-data when used with vert/edge/face/loop data." -); - + "Exposes a single custom data layer, " + "their main purpose is for use as item accessors to custom-data when used with " + "vert/edge/face/loop data."); PyTypeObject BPy_BMLayerAccessVert_Type; /* bm.verts.layers */ PyTypeObject BPy_BMLayerAccessEdge_Type; /* bm.edges.layers */ @@ -801,125 +888,126 @@ PyTypeObject BPy_BMLayerAccessLoop_Type; /* bm.loops.layers */ PyTypeObject BPy_BMLayerCollection_Type; /* bm.loops.layers.uv */ PyTypeObject BPy_BMLayerItem_Type; /* bm.loops.layers.uv["UVMap"] */ - PyObject *BPy_BMLayerAccess_CreatePyObject(BMesh *bm, const char htype) { - BPy_BMLayerAccess *self; - PyTypeObject *type; - - switch (htype) { - case BM_VERT: type = &BPy_BMLayerAccessVert_Type; break; - case BM_EDGE: type = &BPy_BMLayerAccessEdge_Type; break; - case BM_FACE: type = &BPy_BMLayerAccessFace_Type; break; - case BM_LOOP: type = &BPy_BMLayerAccessLoop_Type; break; - default: - { - BLI_assert(0); - type = NULL; - break; - } - } - - self = PyObject_New(BPy_BMLayerAccess, type); - self->bm = bm; - self->htype = htype; - return (PyObject *)self; + BPy_BMLayerAccess *self; + PyTypeObject *type; + + switch (htype) { + case BM_VERT: + type = &BPy_BMLayerAccessVert_Type; + break; + case BM_EDGE: + type = &BPy_BMLayerAccessEdge_Type; + break; + case BM_FACE: + type = &BPy_BMLayerAccessFace_Type; + break; + case BM_LOOP: + type = &BPy_BMLayerAccessLoop_Type; + break; + default: { + BLI_assert(0); + type = NULL; + break; + } + } + + self = PyObject_New(BPy_BMLayerAccess, type); + self->bm = bm; + self->htype = htype; + return (PyObject *)self; } PyObject *BPy_BMLayerCollection_CreatePyObject(BMesh *bm, const char htype, int type) { - BPy_BMLayerCollection *self = PyObject_New(BPy_BMLayerCollection, &BPy_BMLayerCollection_Type); - self->bm = bm; - self->htype = htype; - self->type = type; - return (PyObject *)self; + BPy_BMLayerCollection *self = PyObject_New(BPy_BMLayerCollection, &BPy_BMLayerCollection_Type); + self->bm = bm; + self->htype = htype; + self->type = type; + return (PyObject *)self; } PyObject *BPy_BMLayerItem_CreatePyObject(BMesh *bm, const char htype, int type, int index) { - BPy_BMLayerItem *self = PyObject_New(BPy_BMLayerItem, &BPy_BMLayerItem_Type); - self->bm = bm; - self->htype = htype; - self->type = type; - self->index = index; - return (PyObject *)self; + BPy_BMLayerItem *self = PyObject_New(BPy_BMLayerItem, &BPy_BMLayerItem_Type); + self->bm = bm; + self->htype = htype; + self->type = type; + self->index = index; + return (PyObject *)self; } - void BPy_BM_init_types_customdata(void) { - BPy_BMLayerAccessVert_Type.tp_basicsize = sizeof(BPy_BMLayerAccess); - BPy_BMLayerAccessEdge_Type.tp_basicsize = sizeof(BPy_BMLayerAccess); - BPy_BMLayerAccessFace_Type.tp_basicsize = sizeof(BPy_BMLayerAccess); - BPy_BMLayerAccessLoop_Type.tp_basicsize = sizeof(BPy_BMLayerAccess); - BPy_BMLayerCollection_Type.tp_basicsize = sizeof(BPy_BMLayerCollection); - BPy_BMLayerItem_Type.tp_basicsize = sizeof(BPy_BMLayerItem); - - BPy_BMLayerAccessVert_Type.tp_name = "BMLayerAccessVert"; - BPy_BMLayerAccessEdge_Type.tp_name = "BMLayerAccessEdge"; - BPy_BMLayerAccessFace_Type.tp_name = "BMLayerAccessFace"; - BPy_BMLayerAccessLoop_Type.tp_name = "BMLayerAccessLoop"; - BPy_BMLayerCollection_Type.tp_name = "BMLayerCollection"; - BPy_BMLayerItem_Type.tp_name = "BMLayerItem"; - - /* todo */ - BPy_BMLayerAccessVert_Type.tp_doc = bpy_bmlayeraccess_type_doc; - BPy_BMLayerAccessEdge_Type.tp_doc = bpy_bmlayeraccess_type_doc; - BPy_BMLayerAccessFace_Type.tp_doc = bpy_bmlayeraccess_type_doc; - BPy_BMLayerAccessLoop_Type.tp_doc = bpy_bmlayeraccess_type_doc; - BPy_BMLayerCollection_Type.tp_doc = bpy_bmlayercollection_type_doc; - BPy_BMLayerItem_Type.tp_doc = bpy_bmlayeritem_type_doc; - - BPy_BMLayerAccessVert_Type.tp_repr = (reprfunc)NULL; - BPy_BMLayerAccessEdge_Type.tp_repr = (reprfunc)NULL; - BPy_BMLayerAccessFace_Type.tp_repr = (reprfunc)NULL; - BPy_BMLayerAccessLoop_Type.tp_repr = (reprfunc)NULL; - BPy_BMLayerCollection_Type.tp_repr = (reprfunc)NULL; - BPy_BMLayerItem_Type.tp_repr = (reprfunc)NULL; - - BPy_BMLayerAccessVert_Type.tp_getset = bpy_bmlayeraccess_vert_getseters; - BPy_BMLayerAccessEdge_Type.tp_getset = bpy_bmlayeraccess_edge_getseters; - BPy_BMLayerAccessFace_Type.tp_getset = bpy_bmlayeraccess_face_getseters; - BPy_BMLayerAccessLoop_Type.tp_getset = bpy_bmlayeraccess_loop_getseters; - BPy_BMLayerCollection_Type.tp_getset = bpy_bmlayercollection_getseters; - BPy_BMLayerItem_Type.tp_getset = bpy_bmlayeritem_getseters; - - -// BPy_BMLayerAccess_Type.tp_methods = bpy_bmeditselseq_methods; - BPy_BMLayerCollection_Type.tp_methods = bpy_bmelemseq_methods; - BPy_BMLayerItem_Type.tp_methods = bpy_bmlayeritem_methods; - - BPy_BMLayerCollection_Type.tp_as_sequence = &bpy_bmlayercollection_as_sequence; - - BPy_BMLayerCollection_Type.tp_as_mapping = &bpy_bmlayercollection_as_mapping; - - BPy_BMLayerCollection_Type.tp_iter = (getiterfunc)bpy_bmlayercollection_iter; - - BPy_BMLayerAccessVert_Type.tp_dealloc = NULL; - BPy_BMLayerAccessEdge_Type.tp_dealloc = NULL; - BPy_BMLayerAccessFace_Type.tp_dealloc = NULL; - BPy_BMLayerAccessLoop_Type.tp_dealloc = NULL; - BPy_BMLayerCollection_Type.tp_dealloc = NULL; - BPy_BMLayerItem_Type.tp_dealloc = NULL; - - - - BPy_BMLayerAccessVert_Type.tp_flags = Py_TPFLAGS_DEFAULT; - BPy_BMLayerAccessEdge_Type.tp_flags = Py_TPFLAGS_DEFAULT; - BPy_BMLayerAccessFace_Type.tp_flags = Py_TPFLAGS_DEFAULT; - BPy_BMLayerAccessLoop_Type.tp_flags = Py_TPFLAGS_DEFAULT; - BPy_BMLayerCollection_Type.tp_flags = Py_TPFLAGS_DEFAULT; - BPy_BMLayerItem_Type.tp_flags = Py_TPFLAGS_DEFAULT; - - PyType_Ready(&BPy_BMLayerAccessVert_Type); - PyType_Ready(&BPy_BMLayerAccessEdge_Type); - PyType_Ready(&BPy_BMLayerAccessFace_Type); - PyType_Ready(&BPy_BMLayerAccessLoop_Type); - PyType_Ready(&BPy_BMLayerCollection_Type); - PyType_Ready(&BPy_BMLayerItem_Type); + BPy_BMLayerAccessVert_Type.tp_basicsize = sizeof(BPy_BMLayerAccess); + BPy_BMLayerAccessEdge_Type.tp_basicsize = sizeof(BPy_BMLayerAccess); + BPy_BMLayerAccessFace_Type.tp_basicsize = sizeof(BPy_BMLayerAccess); + BPy_BMLayerAccessLoop_Type.tp_basicsize = sizeof(BPy_BMLayerAccess); + BPy_BMLayerCollection_Type.tp_basicsize = sizeof(BPy_BMLayerCollection); + BPy_BMLayerItem_Type.tp_basicsize = sizeof(BPy_BMLayerItem); + + BPy_BMLayerAccessVert_Type.tp_name = "BMLayerAccessVert"; + BPy_BMLayerAccessEdge_Type.tp_name = "BMLayerAccessEdge"; + BPy_BMLayerAccessFace_Type.tp_name = "BMLayerAccessFace"; + BPy_BMLayerAccessLoop_Type.tp_name = "BMLayerAccessLoop"; + BPy_BMLayerCollection_Type.tp_name = "BMLayerCollection"; + BPy_BMLayerItem_Type.tp_name = "BMLayerItem"; + + /* todo */ + BPy_BMLayerAccessVert_Type.tp_doc = bpy_bmlayeraccess_type_doc; + BPy_BMLayerAccessEdge_Type.tp_doc = bpy_bmlayeraccess_type_doc; + BPy_BMLayerAccessFace_Type.tp_doc = bpy_bmlayeraccess_type_doc; + BPy_BMLayerAccessLoop_Type.tp_doc = bpy_bmlayeraccess_type_doc; + BPy_BMLayerCollection_Type.tp_doc = bpy_bmlayercollection_type_doc; + BPy_BMLayerItem_Type.tp_doc = bpy_bmlayeritem_type_doc; + + BPy_BMLayerAccessVert_Type.tp_repr = (reprfunc)NULL; + BPy_BMLayerAccessEdge_Type.tp_repr = (reprfunc)NULL; + BPy_BMLayerAccessFace_Type.tp_repr = (reprfunc)NULL; + BPy_BMLayerAccessLoop_Type.tp_repr = (reprfunc)NULL; + BPy_BMLayerCollection_Type.tp_repr = (reprfunc)NULL; + BPy_BMLayerItem_Type.tp_repr = (reprfunc)NULL; + + BPy_BMLayerAccessVert_Type.tp_getset = bpy_bmlayeraccess_vert_getseters; + BPy_BMLayerAccessEdge_Type.tp_getset = bpy_bmlayeraccess_edge_getseters; + BPy_BMLayerAccessFace_Type.tp_getset = bpy_bmlayeraccess_face_getseters; + BPy_BMLayerAccessLoop_Type.tp_getset = bpy_bmlayeraccess_loop_getseters; + BPy_BMLayerCollection_Type.tp_getset = bpy_bmlayercollection_getseters; + BPy_BMLayerItem_Type.tp_getset = bpy_bmlayeritem_getseters; + + // BPy_BMLayerAccess_Type.tp_methods = bpy_bmeditselseq_methods; + BPy_BMLayerCollection_Type.tp_methods = bpy_bmelemseq_methods; + BPy_BMLayerItem_Type.tp_methods = bpy_bmlayeritem_methods; + + BPy_BMLayerCollection_Type.tp_as_sequence = &bpy_bmlayercollection_as_sequence; + + BPy_BMLayerCollection_Type.tp_as_mapping = &bpy_bmlayercollection_as_mapping; + + BPy_BMLayerCollection_Type.tp_iter = (getiterfunc)bpy_bmlayercollection_iter; + + BPy_BMLayerAccessVert_Type.tp_dealloc = NULL; + BPy_BMLayerAccessEdge_Type.tp_dealloc = NULL; + BPy_BMLayerAccessFace_Type.tp_dealloc = NULL; + BPy_BMLayerAccessLoop_Type.tp_dealloc = NULL; + BPy_BMLayerCollection_Type.tp_dealloc = NULL; + BPy_BMLayerItem_Type.tp_dealloc = NULL; + + BPy_BMLayerAccessVert_Type.tp_flags = Py_TPFLAGS_DEFAULT; + BPy_BMLayerAccessEdge_Type.tp_flags = Py_TPFLAGS_DEFAULT; + BPy_BMLayerAccessFace_Type.tp_flags = Py_TPFLAGS_DEFAULT; + BPy_BMLayerAccessLoop_Type.tp_flags = Py_TPFLAGS_DEFAULT; + BPy_BMLayerCollection_Type.tp_flags = Py_TPFLAGS_DEFAULT; + BPy_BMLayerItem_Type.tp_flags = Py_TPFLAGS_DEFAULT; + + PyType_Ready(&BPy_BMLayerAccessVert_Type); + PyType_Ready(&BPy_BMLayerAccessEdge_Type); + PyType_Ready(&BPy_BMLayerAccessFace_Type); + PyType_Ready(&BPy_BMLayerAccessLoop_Type); + PyType_Ready(&BPy_BMLayerCollection_Type); + PyType_Ready(&BPy_BMLayerItem_Type); } - /* Per Element Get/Set * ******************* */ @@ -928,46 +1016,42 @@ void BPy_BM_init_types_customdata(void) */ static void *bpy_bmlayeritem_ptr_get(BPy_BMElem *py_ele, BPy_BMLayerItem *py_layer) { - void *value; - BMElem *ele = py_ele->ele; - CustomData *data; - - /* error checking */ - if (UNLIKELY(!BPy_BMLayerItem_Check(py_layer))) { - PyErr_SetString(PyExc_AttributeError, - "BMElem[key]: invalid key, must be a BMLayerItem"); - return NULL; - } - else if (UNLIKELY(py_ele->bm != py_layer->bm)) { - PyErr_SetString(PyExc_ValueError, - "BMElem[layer]: layer is from another mesh"); - return NULL; - } - else if (UNLIKELY(ele->head.htype != py_layer->htype)) { - char namestr_1[32], namestr_2[32]; - PyErr_Format(PyExc_ValueError, - "Layer/Element type mismatch, expected %.200s got layer type %.200s", - BPy_BMElem_StringFromHType_ex(ele->head.htype, namestr_1), - BPy_BMElem_StringFromHType_ex(py_layer->htype, namestr_2)); - return NULL; - } - - data = bpy_bm_customdata_get(py_layer->bm, py_layer->htype); - - value = CustomData_bmesh_get_n(data, ele->head.data, py_layer->type, py_layer->index); - - if (UNLIKELY(value == NULL)) { - /* this should be fairly unlikely but possible if layers move about after we get them */ - PyErr_SetString(PyExc_KeyError, - "BMElem[key]: layer not found"); - return NULL; - } - else { - return value; - } + void *value; + BMElem *ele = py_ele->ele; + CustomData *data; + + /* error checking */ + if (UNLIKELY(!BPy_BMLayerItem_Check(py_layer))) { + PyErr_SetString(PyExc_AttributeError, "BMElem[key]: invalid key, must be a BMLayerItem"); + return NULL; + } + else if (UNLIKELY(py_ele->bm != py_layer->bm)) { + PyErr_SetString(PyExc_ValueError, "BMElem[layer]: layer is from another mesh"); + return NULL; + } + else if (UNLIKELY(ele->head.htype != py_layer->htype)) { + char namestr_1[32], namestr_2[32]; + PyErr_Format(PyExc_ValueError, + "Layer/Element type mismatch, expected %.200s got layer type %.200s", + BPy_BMElem_StringFromHType_ex(ele->head.htype, namestr_1), + BPy_BMElem_StringFromHType_ex(py_layer->htype, namestr_2)); + return NULL; + } + + data = bpy_bm_customdata_get(py_layer->bm, py_layer->htype); + + value = CustomData_bmesh_get_n(data, ele->head.data, py_layer->type, py_layer->index); + + if (UNLIKELY(value == NULL)) { + /* this should be fairly unlikely but possible if layers move about after we get them */ + PyErr_SetString(PyExc_KeyError, "BMElem[key]: layer not found"); + return NULL; + } + else { + return value; + } } - /** *\brief BMElem.__getitem__() * @@ -977,194 +1061,176 @@ static void *bpy_bmlayeritem_ptr_get(BPy_BMElem *py_ele, BPy_BMLayerItem *py_lay */ PyObject *BPy_BMLayerItem_GetItem(BPy_BMElem *py_ele, BPy_BMLayerItem *py_layer) { - void *value = bpy_bmlayeritem_ptr_get(py_ele, py_layer); - PyObject *ret; - - if (UNLIKELY(value == NULL)) { - return NULL; - } - - switch (py_layer->type) { - case CD_MDEFORMVERT: - { - ret = BPy_BMDeformVert_CreatePyObject(value); - break; - } - case CD_PROP_FLT: - case CD_PAINT_MASK: - { - ret = PyFloat_FromDouble(*(float *)value); - break; - } - case CD_PROP_INT: - case CD_FACEMAP: - { - ret = PyLong_FromLong(*(int *)value); - break; - } - case CD_PROP_STR: - { - MStringProperty *mstring = value; - ret = PyBytes_FromStringAndSize(mstring->s, mstring->s_len); - break; - } - case CD_MLOOPUV: - { - ret = BPy_BMLoopUV_CreatePyObject(value); - break; - } - case CD_MLOOPCOL: - { - ret = BPy_BMLoopColor_CreatePyObject(value); - break; - } - case CD_SHAPEKEY: - { - ret = Vector_CreatePyObject_wrap((float *)value, 3, NULL); - break; - } - case CD_BWEIGHT: - { - ret = PyFloat_FromDouble(*(float *)value); - break; - } - case CD_CREASE: - { - ret = PyFloat_FromDouble(*(float *)value); - break; - } - case CD_MVERT_SKIN: - { - ret = BPy_BMVertSkin_CreatePyObject(value); - break; - } - default: - { - ret = Py_NotImplemented; /* TODO */ - Py_INCREF(ret); - break; - } - } - - return ret; + void *value = bpy_bmlayeritem_ptr_get(py_ele, py_layer); + PyObject *ret; + + if (UNLIKELY(value == NULL)) { + return NULL; + } + + switch (py_layer->type) { + case CD_MDEFORMVERT: { + ret = BPy_BMDeformVert_CreatePyObject(value); + break; + } + case CD_PROP_FLT: + case CD_PAINT_MASK: { + ret = PyFloat_FromDouble(*(float *)value); + break; + } + case CD_PROP_INT: + case CD_FACEMAP: { + ret = PyLong_FromLong(*(int *)value); + break; + } + case CD_PROP_STR: { + MStringProperty *mstring = value; + ret = PyBytes_FromStringAndSize(mstring->s, mstring->s_len); + break; + } + case CD_MLOOPUV: { + ret = BPy_BMLoopUV_CreatePyObject(value); + break; + } + case CD_MLOOPCOL: { + ret = BPy_BMLoopColor_CreatePyObject(value); + break; + } + case CD_SHAPEKEY: { + ret = Vector_CreatePyObject_wrap((float *)value, 3, NULL); + break; + } + case CD_BWEIGHT: { + ret = PyFloat_FromDouble(*(float *)value); + break; + } + case CD_CREASE: { + ret = PyFloat_FromDouble(*(float *)value); + break; + } + case CD_MVERT_SKIN: { + ret = BPy_BMVertSkin_CreatePyObject(value); + break; + } + default: { + ret = Py_NotImplemented; /* TODO */ + Py_INCREF(ret); + break; + } + } + + return ret; } int BPy_BMLayerItem_SetItem(BPy_BMElem *py_ele, BPy_BMLayerItem *py_layer, PyObject *py_value) { - int ret = 0; - void *value = bpy_bmlayeritem_ptr_get(py_ele, py_layer); - - if (UNLIKELY(value == NULL)) { - return -1; - } - - switch (py_layer->type) { - case CD_MDEFORMVERT: - { - ret = BPy_BMDeformVert_AssignPyObject(value, py_value); - break; - } - case CD_PROP_FLT: - case CD_PAINT_MASK: - { - float tmp_val = PyFloat_AsDouble(py_value); - if (UNLIKELY(tmp_val == -1 && PyErr_Occurred())) { - PyErr_Format(PyExc_TypeError, "expected a float, not a %.200s", Py_TYPE(py_value)->tp_name); - ret = -1; - } - else { - *(float *)value = tmp_val; - } - break; - } - case CD_PROP_INT: - case CD_FACEMAP: - { - int tmp_val = PyC_Long_AsI32(py_value); - if (UNLIKELY(tmp_val == -1 && PyErr_Occurred())) { - /* error is set */ - ret = -1; - } - else { - *(int *)value = tmp_val; - } - break; - } - case CD_PROP_STR: - { - MStringProperty *mstring = value; - char *tmp_val; - Py_ssize_t tmp_val_len; - if (UNLIKELY(PyBytes_AsStringAndSize(py_value, &tmp_val, &tmp_val_len) == -1)) { - PyErr_Format(PyExc_TypeError, "expected bytes, not a %.200s", Py_TYPE(py_value)->tp_name); - ret = -1; - } - else { - if (tmp_val_len > sizeof(mstring->s)) { - tmp_val_len = sizeof(mstring->s); - } - memcpy(mstring->s, tmp_val, tmp_val_len); - mstring->s_len = tmp_val_len; - } - break; - } - case CD_MLOOPUV: - { - ret = BPy_BMLoopUV_AssignPyObject(value, py_value); - break; - } - case CD_MLOOPCOL: - { - ret = BPy_BMLoopColor_AssignPyObject(value, py_value); - break; - } - case CD_SHAPEKEY: - { - float tmp_val[3]; - if (UNLIKELY(mathutils_array_parse(tmp_val, 3, 3, py_value, "BMVert[shape] = value") == -1)) { - ret = -1; - } - else { - copy_v3_v3((float *)value, tmp_val); - } - break; - } - case CD_BWEIGHT: - { - float tmp_val = PyFloat_AsDouble(py_value); - if (UNLIKELY(tmp_val == -1 && PyErr_Occurred())) { - PyErr_Format(PyExc_TypeError, "expected a float, not a %.200s", Py_TYPE(py_value)->tp_name); - ret = -1; - } - else { - *(float *)value = clamp_f(tmp_val, 0.0f, 1.0f); - } - break; - } - case CD_CREASE: - { - float tmp_val = PyFloat_AsDouble(py_value); - if (UNLIKELY(tmp_val == -1 && PyErr_Occurred())) { - PyErr_Format(PyExc_TypeError, "expected a float, not a %.200s", Py_TYPE(py_value)->tp_name); - ret = -1; - } - else { - *(float *)value = clamp_f(tmp_val, 0.0f, 1.0f); - } - break; - } - case CD_MVERT_SKIN: - { - ret = BPy_BMVertSkin_AssignPyObject(value, py_value); - break; - } - default: - { - PyErr_SetString(PyExc_AttributeError, "readonly / unsupported type"); - ret = -1; - break; - } - } - - return ret; + int ret = 0; + void *value = bpy_bmlayeritem_ptr_get(py_ele, py_layer); + + if (UNLIKELY(value == NULL)) { + return -1; + } + + switch (py_layer->type) { + case CD_MDEFORMVERT: { + ret = BPy_BMDeformVert_AssignPyObject(value, py_value); + break; + } + case CD_PROP_FLT: + case CD_PAINT_MASK: { + float tmp_val = PyFloat_AsDouble(py_value); + if (UNLIKELY(tmp_val == -1 && PyErr_Occurred())) { + PyErr_Format( + PyExc_TypeError, "expected a float, not a %.200s", Py_TYPE(py_value)->tp_name); + ret = -1; + } + else { + *(float *)value = tmp_val; + } + break; + } + case CD_PROP_INT: + case CD_FACEMAP: { + int tmp_val = PyC_Long_AsI32(py_value); + if (UNLIKELY(tmp_val == -1 && PyErr_Occurred())) { + /* error is set */ + ret = -1; + } + else { + *(int *)value = tmp_val; + } + break; + } + case CD_PROP_STR: { + MStringProperty *mstring = value; + char *tmp_val; + Py_ssize_t tmp_val_len; + if (UNLIKELY(PyBytes_AsStringAndSize(py_value, &tmp_val, &tmp_val_len) == -1)) { + PyErr_Format(PyExc_TypeError, "expected bytes, not a %.200s", Py_TYPE(py_value)->tp_name); + ret = -1; + } + else { + if (tmp_val_len > sizeof(mstring->s)) { + tmp_val_len = sizeof(mstring->s); + } + memcpy(mstring->s, tmp_val, tmp_val_len); + mstring->s_len = tmp_val_len; + } + break; + } + case CD_MLOOPUV: { + ret = BPy_BMLoopUV_AssignPyObject(value, py_value); + break; + } + case CD_MLOOPCOL: { + ret = BPy_BMLoopColor_AssignPyObject(value, py_value); + break; + } + case CD_SHAPEKEY: { + float tmp_val[3]; + if (UNLIKELY(mathutils_array_parse(tmp_val, 3, 3, py_value, "BMVert[shape] = value") == + -1)) { + ret = -1; + } + else { + copy_v3_v3((float *)value, tmp_val); + } + break; + } + case CD_BWEIGHT: { + float tmp_val = PyFloat_AsDouble(py_value); + if (UNLIKELY(tmp_val == -1 && PyErr_Occurred())) { + PyErr_Format( + PyExc_TypeError, "expected a float, not a %.200s", Py_TYPE(py_value)->tp_name); + ret = -1; + } + else { + *(float *)value = clamp_f(tmp_val, 0.0f, 1.0f); + } + break; + } + case CD_CREASE: { + float tmp_val = PyFloat_AsDouble(py_value); + if (UNLIKELY(tmp_val == -1 && PyErr_Occurred())) { + PyErr_Format( + PyExc_TypeError, "expected a float, not a %.200s", Py_TYPE(py_value)->tp_name); + ret = -1; + } + else { + *(float *)value = clamp_f(tmp_val, 0.0f, 1.0f); + } + break; + } + case CD_MVERT_SKIN: { + ret = BPy_BMVertSkin_AssignPyObject(value, py_value); + break; + } + default: { + PyErr_SetString(PyExc_AttributeError, "readonly / unsupported type"); + ret = -1; + break; + } + } + + return ret; } |