From e12c08e8d170b7ca40f204a5b0423c23a9fbc2c1 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Wed, 17 Apr 2019 06:17:24 +0200 Subject: 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 --- .../intern/python/Interface0D/BPy_CurvePoint.cpp | 388 ++++++------ .../intern/python/Interface0D/BPy_CurvePoint.h | 4 +- .../intern/python/Interface0D/BPy_SVertex.cpp | 652 +++++++++++---------- .../intern/python/Interface0D/BPy_SVertex.h | 4 +- .../intern/python/Interface0D/BPy_ViewVertex.cpp | 228 +++---- .../intern/python/Interface0D/BPy_ViewVertex.h | 4 +- .../Interface0D/CurvePoint/BPy_StrokeVertex.cpp | 539 +++++++++-------- .../Interface0D/CurvePoint/BPy_StrokeVertex.h | 7 +- .../Interface0D/ViewVertex/BPy_NonTVertex.cpp | 166 +++--- .../python/Interface0D/ViewVertex/BPy_NonTVertex.h | 4 +- .../python/Interface0D/ViewVertex/BPy_TVertex.cpp | 299 +++++----- .../python/Interface0D/ViewVertex/BPy_TVertex.h | 4 +- 12 files changed, 1205 insertions(+), 1094 deletions(-) (limited to 'source/blender/freestyle/intern/python/Interface0D') diff --git a/source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.cpp b/source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.cpp index d000677ab55..e685491f682 100644 --- a/source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.cpp +++ b/source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.cpp @@ -32,236 +32,260 @@ extern "C" { /*----------------------CurvePoint methods----------------------------*/ PyDoc_STRVAR(CurvePoint_doc, -"Class hierarchy: :class:`Interface0D` > :class:`CurvePoint`\n" -"\n" -"Class to represent a point of a curve. A CurvePoint can be any point\n" -"of a 1D curve (it doesn't have to be a vertex of the curve). Any\n" -":class:`Interface1D` is built upon ViewEdges, themselves built upon\n" -"FEdges. Therefore, a curve is basically a polyline made of a list of\n" -":class:`SVertex` objects. Thus, a CurvePoint is built by linearly\n" -"interpolating two :class:`SVertex` instances. CurvePoint can be used\n" -"as virtual points while querying 0D information along a curve at a\n" -"given resolution.\n" -"\n" -".. method:: __init__()\n" -"\n" -" Defult constructor.\n" -"\n" -".. method:: __init__(brother)\n" -"\n" -" Copy constructor.\n" -"\n" -" :arg brother: A CurvePoint object.\n" -" :type brother: :class:`CurvePoint`\n" -"\n" -".. method:: __init__(first_vertex, second_vertex, t2d)\n" -"\n" -" Builds a CurvePoint from two SVertex objects and an interpolation parameter.\n" -"\n" -" :arg first_vertex: The first SVertex.\n" -" :type first_vertex: :class:`SVertex`\n" -" :arg second_vertex: The second SVertex.\n" -" :type second_vertex: :class:`SVertex`\n" -" :arg t2d: A 2D interpolation parameter used to linearly interpolate\n" -" first_vertex and second_vertex.\n" -" :type t2d: float\n" -"\n" -".. method:: __init__(first_point, second_point, t2d)\n" -"\n" -" Builds a CurvePoint from two CurvePoint objects and an interpolation\n" -" parameter.\n" -"\n" -" :arg first_point: The first CurvePoint.\n" -" :type first_point: :class:`CurvePoint`\n" -" :arg second_point: The second CurvePoint.\n" -" :type second_point: :class:`CurvePoint`\n" -" :arg t2d: The 2D interpolation parameter used to linearly interpolate\n" -" first_point and second_point.\n" -" :type t2d: float"); + "Class hierarchy: :class:`Interface0D` > :class:`CurvePoint`\n" + "\n" + "Class to represent a point of a curve. A CurvePoint can be any point\n" + "of a 1D curve (it doesn't have to be a vertex of the curve). Any\n" + ":class:`Interface1D` is built upon ViewEdges, themselves built upon\n" + "FEdges. Therefore, a curve is basically a polyline made of a list of\n" + ":class:`SVertex` objects. Thus, a CurvePoint is built by linearly\n" + "interpolating two :class:`SVertex` instances. CurvePoint can be used\n" + "as virtual points while querying 0D information along a curve at a\n" + "given resolution.\n" + "\n" + ".. method:: __init__()\n" + "\n" + " Defult constructor.\n" + "\n" + ".. method:: __init__(brother)\n" + "\n" + " Copy constructor.\n" + "\n" + " :arg brother: A CurvePoint object.\n" + " :type brother: :class:`CurvePoint`\n" + "\n" + ".. method:: __init__(first_vertex, second_vertex, t2d)\n" + "\n" + " Builds a CurvePoint from two SVertex objects and an interpolation parameter.\n" + "\n" + " :arg first_vertex: The first SVertex.\n" + " :type first_vertex: :class:`SVertex`\n" + " :arg second_vertex: The second SVertex.\n" + " :type second_vertex: :class:`SVertex`\n" + " :arg t2d: A 2D interpolation parameter used to linearly interpolate\n" + " first_vertex and second_vertex.\n" + " :type t2d: float\n" + "\n" + ".. method:: __init__(first_point, second_point, t2d)\n" + "\n" + " Builds a CurvePoint from two CurvePoint objects and an interpolation\n" + " parameter.\n" + "\n" + " :arg first_point: The first CurvePoint.\n" + " :type first_point: :class:`CurvePoint`\n" + " :arg second_point: The second CurvePoint.\n" + " :type second_point: :class:`CurvePoint`\n" + " :arg t2d: The 2D interpolation parameter used to linearly interpolate\n" + " first_point and second_point.\n" + " :type t2d: float"); static int CurvePoint_init(BPy_CurvePoint *self, PyObject *args, PyObject *kwds) { - static const char *kwlist_1[] = {"brother", NULL}; - static const char *kwlist_2[] = {"first_vertex", "second_vertex", "t2d", NULL}; - static const char *kwlist_3[] = {"first_point", "second_point", "t2d", NULL}; - PyObject *obj1 = 0, *obj2 = 0; - float t2d; + static const char *kwlist_1[] = {"brother", NULL}; + static const char *kwlist_2[] = {"first_vertex", "second_vertex", "t2d", NULL}; + static const char *kwlist_3[] = {"first_point", "second_point", "t2d", NULL}; + PyObject *obj1 = 0, *obj2 = 0; + float t2d; - if (PyArg_ParseTupleAndKeywords(args, kwds, "|O!", (char **)kwlist_1, &CurvePoint_Type, &obj1)) { - if (!obj1) - self->cp = new CurvePoint(); - else - self->cp = new CurvePoint(*(((BPy_CurvePoint *)obj1)->cp)); - } - else if (PyErr_Clear(), - PyArg_ParseTupleAndKeywords(args, kwds, "O!O!f", (char **)kwlist_2, - &SVertex_Type, &obj1, &SVertex_Type, &obj2, &t2d)) - { - self->cp = new CurvePoint(((BPy_SVertex *)obj1)->sv, ((BPy_SVertex *)obj2)->sv, t2d); - } - else if (PyErr_Clear(), - PyArg_ParseTupleAndKeywords(args, kwds, "O!O!f", (char **)kwlist_3, - &CurvePoint_Type, &obj1, &CurvePoint_Type, &obj2, &t2d)) - { - CurvePoint *cp1 = ((BPy_CurvePoint *)obj1)->cp; - CurvePoint *cp2 = ((BPy_CurvePoint *)obj2)->cp; - if (!cp1 || cp1->A() == 0 || cp1->B() == 0) { - PyErr_SetString(PyExc_TypeError, "argument 1 is an invalid CurvePoint object"); - return -1; - } - if (!cp2 || cp2->A() == 0 || cp2->B() == 0) { - PyErr_SetString(PyExc_TypeError, "argument 2 is an invalid CurvePoint object"); - return -1; - } - self->cp = new CurvePoint(cp1, cp2, t2d); - } - else { - PyErr_SetString(PyExc_TypeError, "invalid argument(s)"); - return -1; - } - self->py_if0D.if0D = self->cp; - self->py_if0D.borrowed = false; - return 0; + if (PyArg_ParseTupleAndKeywords(args, kwds, "|O!", (char **)kwlist_1, &CurvePoint_Type, &obj1)) { + if (!obj1) + self->cp = new CurvePoint(); + else + self->cp = new CurvePoint(*(((BPy_CurvePoint *)obj1)->cp)); + } + else if (PyErr_Clear(), + PyArg_ParseTupleAndKeywords(args, + kwds, + "O!O!f", + (char **)kwlist_2, + &SVertex_Type, + &obj1, + &SVertex_Type, + &obj2, + &t2d)) { + self->cp = new CurvePoint(((BPy_SVertex *)obj1)->sv, ((BPy_SVertex *)obj2)->sv, t2d); + } + else if (PyErr_Clear(), + PyArg_ParseTupleAndKeywords(args, + kwds, + "O!O!f", + (char **)kwlist_3, + &CurvePoint_Type, + &obj1, + &CurvePoint_Type, + &obj2, + &t2d)) { + CurvePoint *cp1 = ((BPy_CurvePoint *)obj1)->cp; + CurvePoint *cp2 = ((BPy_CurvePoint *)obj2)->cp; + if (!cp1 || cp1->A() == 0 || cp1->B() == 0) { + PyErr_SetString(PyExc_TypeError, "argument 1 is an invalid CurvePoint object"); + return -1; + } + if (!cp2 || cp2->A() == 0 || cp2->B() == 0) { + PyErr_SetString(PyExc_TypeError, "argument 2 is an invalid CurvePoint object"); + return -1; + } + self->cp = new CurvePoint(cp1, cp2, t2d); + } + else { + PyErr_SetString(PyExc_TypeError, "invalid argument(s)"); + return -1; + } + self->py_if0D.if0D = self->cp; + self->py_if0D.borrowed = false; + return 0; } -///bool operator== (const CurvePoint &b) +///bool operator== (const CurvePoint &b) /*----------------------CurvePoint get/setters ----------------------------*/ PyDoc_STRVAR(CurvePoint_first_svertex_doc, -"The first SVertex upon which the CurvePoint is built.\n" -"\n" -":type: :class:`SVertex`"); + "The first SVertex upon which the CurvePoint is built.\n" + "\n" + ":type: :class:`SVertex`"); static PyObject *CurvePoint_first_svertex_get(BPy_CurvePoint *self, void *UNUSED(closure)) { - SVertex *A = self->cp->A(); - if (A) - return BPy_SVertex_from_SVertex(*A); - Py_RETURN_NONE; + SVertex *A = self->cp->A(); + if (A) + return BPy_SVertex_from_SVertex(*A); + Py_RETURN_NONE; } -static int CurvePoint_first_svertex_set(BPy_CurvePoint *self, PyObject *value, void *UNUSED(closure)) +static int CurvePoint_first_svertex_set(BPy_CurvePoint *self, + PyObject *value, + void *UNUSED(closure)) { - if (!BPy_SVertex_Check(value)) { - PyErr_SetString(PyExc_TypeError, "value must be an SVertex"); - return -1; - } - self->cp->setA(((BPy_SVertex *)value)->sv); - return 0; + if (!BPy_SVertex_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be an SVertex"); + return -1; + } + self->cp->setA(((BPy_SVertex *)value)->sv); + return 0; } PyDoc_STRVAR(CurvePoint_second_svertex_doc, -"The second SVertex upon which the CurvePoint is built.\n" -"\n" -":type: :class:`SVertex`"); + "The second SVertex upon which the CurvePoint is built.\n" + "\n" + ":type: :class:`SVertex`"); static PyObject *CurvePoint_second_svertex_get(BPy_CurvePoint *self, void *UNUSED(closure)) { - SVertex *B = self->cp->B(); - if (B) - return BPy_SVertex_from_SVertex(*B); - Py_RETURN_NONE; + SVertex *B = self->cp->B(); + if (B) + return BPy_SVertex_from_SVertex(*B); + Py_RETURN_NONE; } -static int CurvePoint_second_svertex_set(BPy_CurvePoint *self, PyObject *value, void *UNUSED(closure)) +static int CurvePoint_second_svertex_set(BPy_CurvePoint *self, + PyObject *value, + void *UNUSED(closure)) { - if (!BPy_SVertex_Check(value)) { - PyErr_SetString(PyExc_TypeError, "value must be an SVertex"); - return -1; - } - self->cp->setB(((BPy_SVertex *)value)->sv); - return 0; + if (!BPy_SVertex_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be an SVertex"); + return -1; + } + self->cp->setB(((BPy_SVertex *)value)->sv); + return 0; } PyDoc_STRVAR(CurvePoint_fedge_doc, -"Gets the FEdge for the two SVertices that given CurvePoints consists out of.\n" -"A shortcut for CurvePoint.first_svertex.get_fedge(CurvePoint.second_svertex).\n" -"\n" -":type: :class:`FEdge`"); + "Gets the FEdge for the two SVertices that given CurvePoints consists out of.\n" + "A shortcut for CurvePoint.first_svertex.get_fedge(CurvePoint.second_svertex).\n" + "\n" + ":type: :class:`FEdge`"); static PyObject *CurvePoint_fedge_get(BPy_CurvePoint *self, void *UNUSED(closure)) { - SVertex *A = self->cp->A(); - Interface0D *B = (Interface0D *)self->cp->B(); - // B can be NULL under certain circumstances - if (B) - return Any_BPy_Interface1D_from_Interface1D(*(A->getFEdge(*B))); - Py_RETURN_NONE; + SVertex *A = self->cp->A(); + Interface0D *B = (Interface0D *)self->cp->B(); + // B can be NULL under certain circumstances + if (B) + return Any_BPy_Interface1D_from_Interface1D(*(A->getFEdge(*B))); + Py_RETURN_NONE; } PyDoc_STRVAR(CurvePoint_t2d_doc, -"The 2D interpolation parameter.\n" -"\n" -":type: float"); + "The 2D interpolation parameter.\n" + "\n" + ":type: float"); static PyObject *CurvePoint_t2d_get(BPy_CurvePoint *self, void *UNUSED(closure)) { - return PyFloat_FromDouble(self->cp->t2d()); + return PyFloat_FromDouble(self->cp->t2d()); } static int CurvePoint_t2d_set(BPy_CurvePoint *self, PyObject *value, void *UNUSED(closure)) { - float scalar; - if ((scalar = PyFloat_AsDouble(value)) == -1.0f && PyErr_Occurred()) { - PyErr_SetString(PyExc_TypeError, "value must be a number"); - return -1; - } - self->cp->setT2d(scalar); - return 0; + float scalar; + if ((scalar = PyFloat_AsDouble(value)) == -1.0f && PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "value must be a number"); + return -1; + } + self->cp->setT2d(scalar); + return 0; } static PyGetSetDef BPy_CurvePoint_getseters[] = { - {(char *)"first_svertex", (getter)CurvePoint_first_svertex_get, (setter)CurvePoint_first_svertex_set, - (char *)CurvePoint_first_svertex_doc, NULL}, - {(char *)"second_svertex", (getter)CurvePoint_second_svertex_get, (setter)CurvePoint_second_svertex_set, - (char *)CurvePoint_second_svertex_doc, NULL}, - {(char *)"fedge", (getter)CurvePoint_fedge_get, NULL, - CurvePoint_fedge_doc, NULL}, - {(char *)"t2d", (getter)CurvePoint_t2d_get, (setter)CurvePoint_t2d_set, (char *)CurvePoint_t2d_doc, NULL}, - {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ + {(char *)"first_svertex", + (getter)CurvePoint_first_svertex_get, + (setter)CurvePoint_first_svertex_set, + (char *)CurvePoint_first_svertex_doc, + NULL}, + {(char *)"second_svertex", + (getter)CurvePoint_second_svertex_get, + (setter)CurvePoint_second_svertex_set, + (char *)CurvePoint_second_svertex_doc, + NULL}, + {(char *)"fedge", (getter)CurvePoint_fedge_get, NULL, CurvePoint_fedge_doc, NULL}, + {(char *)"t2d", + (getter)CurvePoint_t2d_get, + (setter)CurvePoint_t2d_set, + (char *)CurvePoint_t2d_doc, + NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; /*-----------------------BPy_CurvePoint type definition ------------------------------*/ PyTypeObject CurvePoint_Type = { - PyVarObject_HEAD_INIT(NULL, 0) - "CurvePoint", /* tp_name */ - sizeof(BPy_CurvePoint), /* tp_basicsize */ - 0, /* tp_itemsize */ - 0, /* tp_dealloc */ - 0, /* tp_print */ - 0, /* tp_getattr */ - 0, /* tp_setattr */ - 0, /* tp_reserved */ - 0, /* tp_repr */ - 0, /* tp_as_number */ - 0, /* tp_as_sequence */ - 0, /* tp_as_mapping */ - 0, /* tp_hash */ - 0, /* tp_call */ - 0, /* tp_str */ - 0, /* tp_getattro */ - 0, /* tp_setattro */ - 0, /* tp_as_buffer */ - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ - CurvePoint_doc, /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ - 0, /* tp_iter */ - 0, /* tp_iternext */ - 0, /* tp_methods */ - 0, /* tp_members */ - BPy_CurvePoint_getseters, /* tp_getset */ - &Interface0D_Type, /* tp_base */ - 0, /* tp_dict */ - 0, /* tp_descr_get */ - 0, /* tp_descr_set */ - 0, /* tp_dictoffset */ - (initproc)CurvePoint_init, /* tp_init */ - 0, /* tp_alloc */ - 0, /* tp_new */ + PyVarObject_HEAD_INIT(NULL, 0) "CurvePoint", /* tp_name */ + sizeof(BPy_CurvePoint), /* tp_basicsize */ + 0, /* tp_itemsize */ + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_reserved */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + CurvePoint_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + BPy_CurvePoint_getseters, /* tp_getset */ + &Interface0D_Type, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)CurvePoint_init, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ }; /////////////////////////////////////////////////////////////////////////////////////////// diff --git a/source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.h b/source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.h index 7cc78a12167..d0f4087f8a6 100644 --- a/source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.h +++ b/source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.h @@ -37,8 +37,8 @@ extern PyTypeObject CurvePoint_Type; /*---------------------------Python BPy_CurvePoint structure definition----------*/ typedef struct { - BPy_Interface0D py_if0D; - CurvePoint *cp; + BPy_Interface0D py_if0D; + CurvePoint *cp; } BPy_CurvePoint; /////////////////////////////////////////////////////////////////////////////////////////// diff --git a/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp index f4b232a957e..f4b8ca07d3f 100644 --- a/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp +++ b/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp @@ -33,433 +33,463 @@ extern "C" { /*----------------------SVertex methods ----------------------------*/ PyDoc_STRVAR(SVertex_doc, -"Class hierarchy: :class:`Interface0D` > :class:`SVertex`\n" -"\n" -"Class to define a vertex of the embedding.\n" -"\n" -".. method:: __init__()\n" -"\n" -" Default constructor.\n" -"\n" -".. method:: __init__(brother)\n" -"\n" -" Copy constructor.\n" -"\n" -" :arg brother: A SVertex object.\n" -" :type brother: :class:`SVertex`\n" -"\n" -".. method:: __init__(point_3d, id)\n" -"\n" -" Builds a SVertex from 3D coordinates and an Id.\n" -"\n" -" :arg point_3d: A three-dimensional vector.\n" -" :type point_3d: :class:`mathutils.Vector`\n" -" :arg id: An Id object.\n" -" :type id: :class:`Id`"); + "Class hierarchy: :class:`Interface0D` > :class:`SVertex`\n" + "\n" + "Class to define a vertex of the embedding.\n" + "\n" + ".. method:: __init__()\n" + "\n" + " Default constructor.\n" + "\n" + ".. method:: __init__(brother)\n" + "\n" + " Copy constructor.\n" + "\n" + " :arg brother: A SVertex object.\n" + " :type brother: :class:`SVertex`\n" + "\n" + ".. method:: __init__(point_3d, id)\n" + "\n" + " Builds a SVertex from 3D coordinates and an Id.\n" + "\n" + " :arg point_3d: A three-dimensional vector.\n" + " :type point_3d: :class:`mathutils.Vector`\n" + " :arg id: An Id object.\n" + " :type id: :class:`Id`"); static int SVertex_init(BPy_SVertex *self, PyObject *args, PyObject *kwds) { - static const char *kwlist_1[] = {"brother", NULL}; - static const char *kwlist_2[] = {"point_3d", "id", NULL}; - PyObject *obj = 0; - float v[3]; - - if (PyArg_ParseTupleAndKeywords(args, kwds, "|O!", (char **)kwlist_1, &SVertex_Type, &obj)) { - if (!obj) - self->sv = new SVertex(); - else - self->sv = new SVertex(*(((BPy_SVertex *)obj)->sv)); - } - else if (PyErr_Clear(), - PyArg_ParseTupleAndKeywords(args, kwds, "O&O!", (char **)kwlist_2, convert_v3, v, &Id_Type, &obj)) - { - Vec3r point_3d(v[0], v[1], v[2]); - self->sv = new SVertex(point_3d, *(((BPy_Id *)obj)->id)); - } - else { - PyErr_SetString(PyExc_TypeError, "invalid argument(s)"); - return -1; - } - self->py_if0D.if0D = self->sv; - self->py_if0D.borrowed = false; - return 0; + static const char *kwlist_1[] = {"brother", NULL}; + static const char *kwlist_2[] = {"point_3d", "id", NULL}; + PyObject *obj = 0; + float v[3]; + + if (PyArg_ParseTupleAndKeywords(args, kwds, "|O!", (char **)kwlist_1, &SVertex_Type, &obj)) { + if (!obj) + self->sv = new SVertex(); + else + self->sv = new SVertex(*(((BPy_SVertex *)obj)->sv)); + } + else if (PyErr_Clear(), + PyArg_ParseTupleAndKeywords( + args, kwds, "O&O!", (char **)kwlist_2, convert_v3, v, &Id_Type, &obj)) { + Vec3r point_3d(v[0], v[1], v[2]); + self->sv = new SVertex(point_3d, *(((BPy_Id *)obj)->id)); + } + else { + PyErr_SetString(PyExc_TypeError, "invalid argument(s)"); + return -1; + } + self->py_if0D.if0D = self->sv; + self->py_if0D.borrowed = false; + return 0; } PyDoc_STRVAR(SVertex_add_normal_doc, -".. method:: add_normal(normal)\n" -"\n" -" Adds a normal to the SVertex's set of normals. If the same normal\n" -" is already in the set, nothing changes.\n" -"\n" -" :arg normal: A three-dimensional vector.\n" -" :type normal: :class:`mathutils.Vector`, list or tuple of 3 real numbers"); + ".. method:: add_normal(normal)\n" + "\n" + " Adds a normal to the SVertex's set of normals. If the same normal\n" + " is already in the set, nothing changes.\n" + "\n" + " :arg normal: A three-dimensional vector.\n" + " :type normal: :class:`mathutils.Vector`, list or tuple of 3 real numbers"); static PyObject *SVertex_add_normal(BPy_SVertex *self, PyObject *args, PyObject *kwds) { - static const char *kwlist[] = {"normal", NULL}; - PyObject *py_normal; - Vec3r n; - - if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", (char **)kwlist, &py_normal)) - return NULL; - if (!Vec3r_ptr_from_PyObject(py_normal, n)) { - PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)"); - return NULL; - } - self->sv->AddNormal(n); - Py_RETURN_NONE; + static const char *kwlist[] = {"normal", NULL}; + PyObject *py_normal; + Vec3r n; + + if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", (char **)kwlist, &py_normal)) + return NULL; + if (!Vec3r_ptr_from_PyObject(py_normal, n)) { + PyErr_SetString(PyExc_TypeError, + "argument 1 must be a 3D vector (either a list of 3 elements or Vector)"); + return NULL; + } + self->sv->AddNormal(n); + Py_RETURN_NONE; } PyDoc_STRVAR(SVertex_add_fedge_doc, -".. method:: add_fedge(fedge)\n" -"\n" -" Add an FEdge to the list of edges emanating from this SVertex.\n" -"\n" -" :arg fedge: An FEdge.\n" -" :type fedge: :class:`FEdge`"); + ".. method:: add_fedge(fedge)\n" + "\n" + " Add an FEdge to the list of edges emanating from this SVertex.\n" + "\n" + " :arg fedge: An FEdge.\n" + " :type fedge: :class:`FEdge`"); static PyObject *SVertex_add_fedge(BPy_SVertex *self, PyObject *args, PyObject *kwds) { - static const char *kwlist[] = {"fedge", NULL}; - PyObject *py_fe; + static const char *kwlist[] = {"fedge", NULL}; + PyObject *py_fe; - if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &FEdge_Type, &py_fe)) - return NULL; - self->sv->AddFEdge(((BPy_FEdge *)py_fe)->fe); - Py_RETURN_NONE; + if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &FEdge_Type, &py_fe)) + return NULL; + self->sv->AddFEdge(((BPy_FEdge *)py_fe)->fe); + Py_RETURN_NONE; } -// virtual bool operator== (const SVertex &brother) +// virtual bool operator== (const SVertex &brother) static PyMethodDef BPy_SVertex_methods[] = { - {"add_normal", (PyCFunction)SVertex_add_normal, METH_VARARGS | METH_KEYWORDS, SVertex_add_normal_doc}, - {"add_fedge", (PyCFunction)SVertex_add_fedge, METH_VARARGS | METH_KEYWORDS, SVertex_add_fedge_doc}, - {NULL, NULL, 0, NULL}, + {"add_normal", + (PyCFunction)SVertex_add_normal, + METH_VARARGS | METH_KEYWORDS, + SVertex_add_normal_doc}, + {"add_fedge", + (PyCFunction)SVertex_add_fedge, + METH_VARARGS | METH_KEYWORDS, + SVertex_add_fedge_doc}, + {NULL, NULL, 0, NULL}, }; /*----------------------mathutils callbacks ----------------------------*/ /* subtype */ -#define MATHUTILS_SUBTYPE_POINT3D 1 -#define MATHUTILS_SUBTYPE_POINT2D 2 +#define MATHUTILS_SUBTYPE_POINT3D 1 +#define MATHUTILS_SUBTYPE_POINT2D 2 static int SVertex_mathutils_check(BaseMathObject *bmo) { - if (!BPy_SVertex_Check(bmo->cb_user)) - return -1; - return 0; + if (!BPy_SVertex_Check(bmo->cb_user)) + return -1; + return 0; } static int SVertex_mathutils_get(BaseMathObject *bmo, int subtype) { - BPy_SVertex *self = (BPy_SVertex *)bmo->cb_user; - switch (subtype) { - case MATHUTILS_SUBTYPE_POINT3D: - bmo->data[0] = self->sv->getX(); - bmo->data[1] = self->sv->getY(); - bmo->data[2] = self->sv->getZ(); - break; - case MATHUTILS_SUBTYPE_POINT2D: - bmo->data[0] = self->sv->getProjectedX(); - bmo->data[1] = self->sv->getProjectedY(); - bmo->data[2] = self->sv->getProjectedZ(); - break; - default: - return -1; - } - return 0; + BPy_SVertex *self = (BPy_SVertex *)bmo->cb_user; + switch (subtype) { + case MATHUTILS_SUBTYPE_POINT3D: + bmo->data[0] = self->sv->getX(); + bmo->data[1] = self->sv->getY(); + bmo->data[2] = self->sv->getZ(); + break; + case MATHUTILS_SUBTYPE_POINT2D: + bmo->data[0] = self->sv->getProjectedX(); + bmo->data[1] = self->sv->getProjectedY(); + bmo->data[2] = self->sv->getProjectedZ(); + break; + default: + return -1; + } + return 0; } static int SVertex_mathutils_set(BaseMathObject *bmo, int subtype) { - BPy_SVertex *self = (BPy_SVertex *)bmo->cb_user; - switch (subtype) { - case MATHUTILS_SUBTYPE_POINT3D: - { - Vec3r p(bmo->data[0], bmo->data[1], bmo->data[2]); - self->sv->setPoint3D(p); - } - break; - case MATHUTILS_SUBTYPE_POINT2D: - { - Vec3r p(bmo->data[0], bmo->data[1], bmo->data[2]); - self->sv->setPoint2D(p); - } - break; - default: - return -1; - } - return 0; + BPy_SVertex *self = (BPy_SVertex *)bmo->cb_user; + switch (subtype) { + case MATHUTILS_SUBTYPE_POINT3D: { + Vec3r p(bmo->data[0], bmo->data[1], bmo->data[2]); + self->sv->setPoint3D(p); + } break; + case MATHUTILS_SUBTYPE_POINT2D: { + Vec3r p(bmo->data[0], bmo->data[1], bmo->data[2]); + self->sv->setPoint2D(p); + } break; + default: + return -1; + } + return 0; } static int SVertex_mathutils_get_index(BaseMathObject *bmo, int subtype, int index) { - BPy_SVertex *self = (BPy_SVertex *)bmo->cb_user; - switch (subtype) { - case MATHUTILS_SUBTYPE_POINT3D: - switch (index) { - case 0: bmo->data[0] = self->sv->getX(); break; - case 1: bmo->data[1] = self->sv->getY(); break; - case 2: bmo->data[2] = self->sv->getZ(); break; - default: - return -1; - } - break; - case MATHUTILS_SUBTYPE_POINT2D: - switch (index) { - case 0: bmo->data[0] = self->sv->getProjectedX(); break; - case 1: bmo->data[1] = self->sv->getProjectedY(); break; - case 2: bmo->data[2] = self->sv->getProjectedZ(); break; - default: - return -1; - } - break; - default: - return -1; - } - return 0; + BPy_SVertex *self = (BPy_SVertex *)bmo->cb_user; + switch (subtype) { + case MATHUTILS_SUBTYPE_POINT3D: + switch (index) { + case 0: + bmo->data[0] = self->sv->getX(); + break; + case 1: + bmo->data[1] = self->sv->getY(); + break; + case 2: + bmo->data[2] = self->sv->getZ(); + break; + default: + return -1; + } + break; + case MATHUTILS_SUBTYPE_POINT2D: + switch (index) { + case 0: + bmo->data[0] = self->sv->getProjectedX(); + break; + case 1: + bmo->data[1] = self->sv->getProjectedY(); + break; + case 2: + bmo->data[2] = self->sv->getProjectedZ(); + break; + default: + return -1; + } + break; + default: + return -1; + } + return 0; } static int SVertex_mathutils_set_index(BaseMathObject *bmo, int subtype, int index) { - BPy_SVertex *self = (BPy_SVertex *)bmo->cb_user; - switch (subtype) { - case MATHUTILS_SUBTYPE_POINT3D: - { - Vec3r p(self->sv->point3D()); - p[index] = bmo->data[index]; - self->sv->setPoint3D(p); - } - break; - case MATHUTILS_SUBTYPE_POINT2D: - { - Vec3r p(self->sv->point2D()); - p[index] = bmo->data[index]; - self->sv->setPoint2D(p); - } - break; - default: - return -1; - } - return 0; + BPy_SVertex *self = (BPy_SVertex *)bmo->cb_user; + switch (subtype) { + case MATHUTILS_SUBTYPE_POINT3D: { + Vec3r p(self->sv->point3D()); + p[index] = bmo->data[index]; + self->sv->setPoint3D(p); + } break; + case MATHUTILS_SUBTYPE_POINT2D: { + Vec3r p(self->sv->point2D()); + p[index] = bmo->data[index]; + self->sv->setPoint2D(p); + } break; + default: + return -1; + } + return 0; } static Mathutils_Callback SVertex_mathutils_cb = { - SVertex_mathutils_check, - SVertex_mathutils_get, - SVertex_mathutils_set, - SVertex_mathutils_get_index, - SVertex_mathutils_set_index, + SVertex_mathutils_check, + SVertex_mathutils_get, + SVertex_mathutils_set, + SVertex_mathutils_get_index, + SVertex_mathutils_set_index, }; static unsigned char SVertex_mathutils_cb_index = -1; void SVertex_mathutils_register_callback() { - SVertex_mathutils_cb_index = Mathutils_RegisterCallback(&SVertex_mathutils_cb); + SVertex_mathutils_cb_index = Mathutils_RegisterCallback(&SVertex_mathutils_cb); } /*----------------------SVertex get/setters ----------------------------*/ PyDoc_STRVAR(SVertex_point_3d_doc, -"The 3D coordinates of the SVertex.\n" -"\n" -":type: :class:`mathutils.Vector`"); + "The 3D coordinates of the SVertex.\n" + "\n" + ":type: :class:`mathutils.Vector`"); static PyObject *SVertex_point_3d_get(BPy_SVertex *self, void *UNUSED(closure)) { - return Vector_CreatePyObject_cb((PyObject *)self, 3, SVertex_mathutils_cb_index, MATHUTILS_SUBTYPE_POINT3D); + return Vector_CreatePyObject_cb( + (PyObject *)self, 3, SVertex_mathutils_cb_index, MATHUTILS_SUBTYPE_POINT3D); } static int SVertex_point_3d_set(BPy_SVertex *self, PyObject *value, void *UNUSED(closure)) { - float v[3]; - if (mathutils_array_parse(v, 3, 3, value, - "value must be a 3-dimensional vector") == -1) - { - return -1; - } - Vec3r p(v[0], v[1], v[2]); - self->sv->setPoint3D(p); - return 0; + float v[3]; + if (mathutils_array_parse(v, 3, 3, value, "value must be a 3-dimensional vector") == -1) { + return -1; + } + Vec3r p(v[0], v[1], v[2]); + self->sv->setPoint3D(p); + return 0; } PyDoc_STRVAR(SVertex_point_2d_doc, -"The projected 3D coordinates of the SVertex.\n" -"\n" -":type: :class:`mathutils.Vector`"); + "The projected 3D coordinates of the SVertex.\n" + "\n" + ":type: :class:`mathutils.Vector`"); static PyObject *SVertex_point_2d_get(BPy_SVertex *self, void *UNUSED(closure)) { - return Vector_CreatePyObject_cb((PyObject *)self, 3, SVertex_mathutils_cb_index, MATHUTILS_SUBTYPE_POINT2D); + return Vector_CreatePyObject_cb( + (PyObject *)self, 3, SVertex_mathutils_cb_index, MATHUTILS_SUBTYPE_POINT2D); } static int SVertex_point_2d_set(BPy_SVertex *self, PyObject *value, void *UNUSED(closure)) { - float v[3]; - if (mathutils_array_parse(v, 3, 3, value, - "value must be a 3-dimensional vector") == -1) - { - return -1; - } - Vec3r p(v[0], v[1], v[2]); - self->sv->setPoint2D(p); - return 0; + float v[3]; + if (mathutils_array_parse(v, 3, 3, value, "value must be a 3-dimensional vector") == -1) { + return -1; + } + Vec3r p(v[0], v[1], v[2]); + self->sv->setPoint2D(p); + return 0; } PyDoc_STRVAR(SVertex_id_doc, -"The Id of this SVertex.\n" -"\n" -":type: :class:`Id`"); + "The Id of this SVertex.\n" + "\n" + ":type: :class:`Id`"); static PyObject *SVertex_id_get(BPy_SVertex *self, void *UNUSED(closure)) { - Id id(self->sv->getId()); - return BPy_Id_from_Id(id); // return a copy + Id id(self->sv->getId()); + return BPy_Id_from_Id(id); // return a copy } static int SVertex_id_set(BPy_SVertex *self, PyObject *value, void *UNUSED(closure)) { - if (!BPy_Id_Check(value)) { - PyErr_SetString(PyExc_TypeError, "value must be an Id"); - return -1; - } - self->sv->setId(*(((BPy_Id *)value)->id)); - return 0; + if (!BPy_Id_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be an Id"); + return -1; + } + self->sv->setId(*(((BPy_Id *)value)->id)); + return 0; } PyDoc_STRVAR(SVertex_normals_doc, -"The normals for this Vertex as a list. In a sharp surface, an SVertex\n" -"has exactly one normal. In a smooth surface, an SVertex can have any\n" -"number of normals.\n" -"\n" -":type: list of :class:`mathutils.Vector` objects"); + "The normals for this Vertex as a list. In a sharp surface, an SVertex\n" + "has exactly one normal. In a smooth surface, an SVertex can have any\n" + "number of normals.\n" + "\n" + ":type: list of :class:`mathutils.Vector` objects"); static PyObject *SVertex_normals_get(BPy_SVertex *self, void *UNUSED(closure)) { - PyObject *py_normals; - set< Vec3r > normals = self->sv->normals(); - set< Vec3r >::iterator it; - py_normals = PyList_New(normals.size()); - unsigned int i = 0; - - for (it = normals.begin(); it != normals.end(); it++) { - Vec3r v(*it); - PyList_SET_ITEM(py_normals, i++, Vector_from_Vec3r(v)); - } - return py_normals; + PyObject *py_normals; + set normals = self->sv->normals(); + set::iterator it; + py_normals = PyList_New(normals.size()); + unsigned int i = 0; + + for (it = normals.begin(); it != normals.end(); it++) { + Vec3r v(*it); + PyList_SET_ITEM(py_normals, i++, Vector_from_Vec3r(v)); + } + return py_normals; } PyDoc_STRVAR(SVertex_normals_size_doc, -"The number of different normals for this SVertex.\n" -"\n" -":type: int"); + "The number of different normals for this SVertex.\n" + "\n" + ":type: int"); static PyObject *SVertex_normals_size_get(BPy_SVertex *self, void *UNUSED(closure)) { - return PyLong_FromLong(self->sv->normalsSize()); + return PyLong_FromLong(self->sv->normalsSize()); } PyDoc_STRVAR(SVertex_viewvertex_doc, -"If this SVertex is also a ViewVertex, this property refers to the\n" -"ViewVertex, and None otherwise.\n" -"\n" -":type: :class:`ViewVertex`"); + "If this SVertex is also a ViewVertex, this property refers to the\n" + "ViewVertex, and None otherwise.\n" + "\n" + ":type: :class:`ViewVertex`"); static PyObject *SVertex_viewvertex_get(BPy_SVertex *self, void *UNUSED(closure)) { - ViewVertex *vv = self->sv->viewvertex(); - if (vv) - return Any_BPy_ViewVertex_from_ViewVertex(*vv); - Py_RETURN_NONE; + ViewVertex *vv = self->sv->viewvertex(); + if (vv) + return Any_BPy_ViewVertex_from_ViewVertex(*vv); + Py_RETURN_NONE; } PyDoc_STRVAR(SVertex_curvatures_doc, -"Curvature information expressed in the form of a seven-element tuple\n" -"(K1, e1, K2, e2, Kr, er, dKr), where K1 and K2 are scalar values\n" -"representing the first (maximum) and second (minimum) principal\n" -"curvatures at this SVertex, respectively; e1 and e2 are\n" -"three-dimensional vectors representing the first and second principal\n" -"directions, i.e. the directions of the normal plane where the\n" -"curvature takes its maximum and minimum values, respectively; and Kr,\n" -"er and dKr are the radial curvature, radial direction, and the\n" -"derivative of the radial curvature at this SVertex, respectively.\n" -"\n" -":type: tuple"); + "Curvature information expressed in the form of a seven-element tuple\n" + "(K1, e1, K2, e2, Kr, er, dKr), where K1 and K2 are scalar values\n" + "representing the first (maximum) and second (minimum) principal\n" + "curvatures at this SVertex, respectively; e1 and e2 are\n" + "three-dimensional vectors representing the first and second principal\n" + "directions, i.e. the directions of the normal plane where the\n" + "curvature takes its maximum and minimum values, respectively; and Kr,\n" + "er and dKr are the radial curvature, radial direction, and the\n" + "derivative of the radial curvature at this SVertex, respectively.\n" + "\n" + ":type: tuple"); static PyObject *SVertex_curvatures_get(BPy_SVertex *self, void *UNUSED(closure)) { - const CurvatureInfo *info = self->sv->getCurvatureInfo(); - if (!info) - Py_RETURN_NONE; - Vec3r e1(info->e1.x(), info->e1.y(), info->e1.z()); - Vec3r e2(info->e2.x(), info->e2.y(), info->e2.z()); - Vec3r er(info->er.x(), info->er.y(), info->er.z()); - PyObject *retval = PyTuple_New(7); - PyTuple_SET_ITEMS(retval, - PyFloat_FromDouble(info->K1), - PyFloat_FromDouble(info->K2), - Vector_from_Vec3r(e1), - Vector_from_Vec3r(e2), - PyFloat_FromDouble(info->Kr), - Vector_from_Vec3r(er), - PyFloat_FromDouble(info->dKr)); - return retval; + const CurvatureInfo *info = self->sv->getCurvatureInfo(); + if (!info) + Py_RETURN_NONE; + Vec3r e1(info->e1.x(), info->e1.y(), info->e1.z()); + Vec3r e2(info->e2.x(), info->e2.y(), info->e2.z()); + Vec3r er(info->er.x(), info->er.y(), info->er.z()); + PyObject *retval = PyTuple_New(7); + PyTuple_SET_ITEMS(retval, + PyFloat_FromDouble(info->K1), + PyFloat_FromDouble(info->K2), + Vector_from_Vec3r(e1), + Vector_from_Vec3r(e2), + PyFloat_FromDouble(info->Kr), + Vector_from_Vec3r(er), + PyFloat_FromDouble(info->dKr)); + return retval; } static PyGetSetDef BPy_SVertex_getseters[] = { - {(char *)"point_3d", (getter)SVertex_point_3d_get, (setter)SVertex_point_3d_set, - (char *)SVertex_point_3d_doc, NULL}, - {(char *)"point_2d", (getter)SVertex_point_2d_get, (setter)SVertex_point_2d_set, - (char *)SVertex_point_2d_doc, NULL}, - {(char *)"id", (getter)SVertex_id_get, (setter)SVertex_id_set, (char *)SVertex_id_doc, NULL}, - {(char *)"normals", (getter)SVertex_normals_get, (setter)NULL, (char *)SVertex_normals_doc, NULL}, - {(char *)"normals_size", (getter)SVertex_normals_size_get, (setter)NULL, (char *)SVertex_normals_size_doc, NULL}, - {(char *)"viewvertex", (getter)SVertex_viewvertex_get, (setter)NULL, (char *)SVertex_viewvertex_doc, NULL}, - {(char *)"curvatures", (getter)SVertex_curvatures_get, (setter)NULL, (char *)SVertex_curvatures_doc, NULL}, - {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ + {(char *)"point_3d", + (getter)SVertex_point_3d_get, + (setter)SVertex_point_3d_set, + (char *)SVertex_point_3d_doc, + NULL}, + {(char *)"point_2d", + (getter)SVertex_point_2d_get, + (setter)SVertex_point_2d_set, + (char *)SVertex_point_2d_doc, + NULL}, + {(char *)"id", (getter)SVertex_id_get, (setter)SVertex_id_set, (char *)SVertex_id_doc, NULL}, + {(char *)"normals", + (getter)SVertex_normals_get, + (setter)NULL, + (char *)SVertex_normals_doc, + NULL}, + {(char *)"normals_size", + (getter)SVertex_normals_size_get, + (setter)NULL, + (char *)SVertex_normals_size_doc, + NULL}, + {(char *)"viewvertex", + (getter)SVertex_viewvertex_get, + (setter)NULL, + (char *)SVertex_viewvertex_doc, + NULL}, + {(char *)"curvatures", + (getter)SVertex_curvatures_get, + (setter)NULL, + (char *)SVertex_curvatures_doc, + NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; /*-----------------------BPy_SVertex type definition ------------------------------*/ PyTypeObject SVertex_Type = { - PyVarObject_HEAD_INIT(NULL, 0) - "SVertex", /* tp_name */ - sizeof(BPy_SVertex), /* tp_basicsize */ - 0, /* tp_itemsize */ - 0, /* tp_dealloc */ - 0, /* tp_print */ - 0, /* tp_getattr */ - 0, /* tp_setattr */ - 0, /* tp_reserved */ - 0, /* tp_repr */ - 0, /* tp_as_number */ - 0, /* tp_as_sequence */ - 0, /* tp_as_mapping */ - 0, /* tp_hash */ - 0, /* tp_call */ - 0, /* tp_str */ - 0, /* tp_getattro */ - 0, /* tp_setattro */ - 0, /* tp_as_buffer */ - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ - SVertex_doc, /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ - 0, /* tp_iter */ - 0, /* tp_iternext */ - BPy_SVertex_methods, /* tp_methods */ - 0, /* tp_members */ - BPy_SVertex_getseters, /* tp_getset */ - &Interface0D_Type, /* tp_base */ - 0, /* tp_dict */ - 0, /* tp_descr_get */ - 0, /* tp_descr_set */ - 0, /* tp_dictoffset */ - (initproc)SVertex_init, /* tp_init */ - 0, /* tp_alloc */ - 0, /* tp_new */ + PyVarObject_HEAD_INIT(NULL, 0) "SVertex", /* tp_name */ + sizeof(BPy_SVertex), /* tp_basicsize */ + 0, /* tp_itemsize */ + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_reserved */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + SVertex_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + BPy_SVertex_methods, /* tp_methods */ + 0, /* tp_members */ + BPy_SVertex_getseters, /* tp_getset */ + &Interface0D_Type, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)SVertex_init, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ }; /////////////////////////////////////////////////////////////////////////////////////////// diff --git a/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.h b/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.h index dabc7119539..20a14f1422c 100644 --- a/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.h +++ b/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.h @@ -37,8 +37,8 @@ extern PyTypeObject SVertex_Type; /*---------------------------Python BPy_SVertex structure definition----------*/ typedef struct { - BPy_Interface0D py_if0D; - SVertex *sv; + BPy_Interface0D py_if0D; + SVertex *sv; } BPy_SVertex; /*---------------------------Python BPy_SVertex visible prototypes-----------*/ diff --git a/source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.cpp index 155dbf26888..1ff46482911 100644 --- a/source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.cpp +++ b/source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.cpp @@ -33,164 +33,168 @@ extern "C" { /*----------------------ViewVertex methods----------------------------*/ PyDoc_STRVAR(ViewVertex_doc, -"Class hierarchy: :class:`Interface0D` > :class:`ViewVertex`\n" -"\n" -"Class to define a view vertex. A view vertex is a feature vertex\n" -"corresponding to a point of the image graph, where the characteristics\n" -"of an edge (e.g., nature and visibility) might change. A\n" -":class:`ViewVertex` can be of two kinds: A :class:`TVertex` when it\n" -"corresponds to the intersection between two ViewEdges or a\n" -":class:`NonTVertex` when it corresponds to a vertex of the initial\n" -"input mesh (it is the case for vertices such as corners for example).\n" -"Thus, this class can be specialized into two classes, the\n" -":class:`TVertex` class and the :class:`NonTVertex` class."); + "Class hierarchy: :class:`Interface0D` > :class:`ViewVertex`\n" + "\n" + "Class to define a view vertex. A view vertex is a feature vertex\n" + "corresponding to a point of the image graph, where the characteristics\n" + "of an edge (e.g., nature and visibility) might change. A\n" + ":class:`ViewVertex` can be of two kinds: A :class:`TVertex` when it\n" + "corresponds to the intersection between two ViewEdges or a\n" + ":class:`NonTVertex` when it corresponds to a vertex of the initial\n" + "input mesh (it is the case for vertices such as corners for example).\n" + "Thus, this class can be specialized into two classes, the\n" + ":class:`TVertex` class and the :class:`NonTVertex` class."); static int ViewVertex_init(BPy_ViewVertex * /*self*/, PyObject * /*args*/, PyObject * /*kwds*/) { - PyErr_SetString(PyExc_TypeError, "cannot instantiate abstract class"); - return -1; + PyErr_SetString(PyExc_TypeError, "cannot instantiate abstract class"); + return -1; } PyDoc_STRVAR(ViewVertex_edges_begin_doc, -".. method:: edges_begin()\n" -"\n" -" Returns an iterator over the ViewEdges that goes to or comes from\n" -" this ViewVertex pointing to the first ViewEdge of the list. The\n" -" orientedViewEdgeIterator allows to iterate in CCW order over these\n" -" ViewEdges and to get the orientation for each ViewEdge\n" -" (incoming/outgoing).\n" -"\n" -" :return: An orientedViewEdgeIterator pointing to the first ViewEdge.\n" -" :rtype: :class:`orientedViewEdgeIterator`"); + ".. method:: edges_begin()\n" + "\n" + " Returns an iterator over the ViewEdges that goes to or comes from\n" + " this ViewVertex pointing to the first ViewEdge of the list. The\n" + " orientedViewEdgeIterator allows to iterate in CCW order over these\n" + " ViewEdges and to get the orientation for each ViewEdge\n" + " (incoming/outgoing).\n" + "\n" + " :return: An orientedViewEdgeIterator pointing to the first ViewEdge.\n" + " :rtype: :class:`orientedViewEdgeIterator`"); static PyObject *ViewVertex_edges_begin(BPy_ViewVertex *self) { - ViewVertexInternal::orientedViewEdgeIterator ove_it(self->vv->edgesBegin()); - return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator(ove_it, false); + ViewVertexInternal::orientedViewEdgeIterator ove_it(self->vv->edgesBegin()); + return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator(ove_it, false); } PyDoc_STRVAR(ViewVertex_edges_end_doc, -".. method:: edges_end()\n" -"\n" -" Returns an orientedViewEdgeIterator over the ViewEdges around this\n" -" ViewVertex, pointing after the last ViewEdge.\n" -"\n" -" :return: An orientedViewEdgeIterator pointing after the last ViewEdge.\n" -" :rtype: :class:`orientedViewEdgeIterator`"); + ".. method:: edges_end()\n" + "\n" + " Returns an orientedViewEdgeIterator over the ViewEdges around this\n" + " ViewVertex, pointing after the last ViewEdge.\n" + "\n" + " :return: An orientedViewEdgeIterator pointing after the last ViewEdge.\n" + " :rtype: :class:`orientedViewEdgeIterator`"); static PyObject *ViewVertex_edges_end(BPy_ViewVertex * /*self*/) { #if 0 - ViewVertexInternal::orientedViewEdgeIterator ove_it(self->vv->edgesEnd()); - return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator(ove_it, 1); + ViewVertexInternal::orientedViewEdgeIterator ove_it(self->vv->edgesEnd()); + return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator(ove_it, 1); #else - PyErr_SetString(PyExc_NotImplementedError, "edges_end method currently disabled"); - return NULL; + PyErr_SetString(PyExc_NotImplementedError, "edges_end method currently disabled"); + return NULL; #endif } PyDoc_STRVAR(ViewVertex_edges_iterator_doc, -".. method:: edges_iterator(edge)\n" -"\n" -" Returns an orientedViewEdgeIterator pointing to the ViewEdge given\n" -" as argument.\n" -"\n" -" :arg edge: A ViewEdge object.\n" -" :type edge: :class:`ViewEdge`\n" -" :return: An orientedViewEdgeIterator pointing to the given ViewEdge.\n" -" :rtype: :class:`orientedViewEdgeIterator`"); + ".. method:: edges_iterator(edge)\n" + "\n" + " Returns an orientedViewEdgeIterator pointing to the ViewEdge given\n" + " as argument.\n" + "\n" + " :arg edge: A ViewEdge object.\n" + " :type edge: :class:`ViewEdge`\n" + " :return: An orientedViewEdgeIterator pointing to the given ViewEdge.\n" + " :rtype: :class:`orientedViewEdgeIterator`"); static PyObject *ViewVertex_edges_iterator(BPy_ViewVertex *self, PyObject *args, PyObject *kwds) { - static const char *kwlist[] = {"edge", NULL}; - PyObject *py_ve; - - if (PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &ViewEdge_Type, &py_ve)) - return NULL; - ViewEdge *ve = ((BPy_ViewEdge *)py_ve)->ve; - ViewVertexInternal::orientedViewEdgeIterator ove_it(self->vv->edgesIterator(ve)); - return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator(ove_it, false); + static const char *kwlist[] = {"edge", NULL}; + PyObject *py_ve; + + if (PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &ViewEdge_Type, &py_ve)) + return NULL; + ViewEdge *ve = ((BPy_ViewEdge *)py_ve)->ve; + ViewVertexInternal::orientedViewEdgeIterator ove_it(self->vv->edgesIterator(ve)); + return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator(ove_it, false); } static PyMethodDef BPy_ViewVertex_methods[] = { - {"edges_begin", (PyCFunction)ViewVertex_edges_begin, METH_NOARGS, ViewVertex_edges_begin_doc}, - {"edges_end", (PyCFunction)ViewVertex_edges_end, METH_NOARGS, ViewVertex_edges_end_doc}, - {"edges_iterator", (PyCFunction)ViewVertex_edges_iterator, METH_VARARGS | METH_KEYWORDS, - ViewVertex_edges_iterator_doc}, - {NULL, NULL, 0, NULL}, + {"edges_begin", (PyCFunction)ViewVertex_edges_begin, METH_NOARGS, ViewVertex_edges_begin_doc}, + {"edges_end", (PyCFunction)ViewVertex_edges_end, METH_NOARGS, ViewVertex_edges_end_doc}, + {"edges_iterator", + (PyCFunction)ViewVertex_edges_iterator, + METH_VARARGS | METH_KEYWORDS, + ViewVertex_edges_iterator_doc}, + {NULL, NULL, 0, NULL}, }; /*----------------------ViewVertex get/setters ----------------------------*/ PyDoc_STRVAR(ViewVertex_nature_doc, -"The nature of this ViewVertex.\n" -"\n" -":type: :class:`Nature`"); + "The nature of this ViewVertex.\n" + "\n" + ":type: :class:`Nature`"); static PyObject *ViewVertex_nature_get(BPy_ViewVertex *self, void *UNUSED(closure)) { - Nature::VertexNature nature = self->vv->getNature(); - if (PyErr_Occurred()) - return NULL; - return BPy_Nature_from_Nature(nature); // return a copy + Nature::VertexNature nature = self->vv->getNature(); + if (PyErr_Occurred()) + return NULL; + return BPy_Nature_from_Nature(nature); // return a copy } static int ViewVertex_nature_set(BPy_ViewVertex *self, PyObject *value, void *UNUSED(closure)) { - if (!BPy_Nature_Check(value)) { - PyErr_SetString(PyExc_TypeError, "value must be a Nature"); - return -1; - } - self->vv->setNature(PyLong_AsLong((PyObject *)&((BPy_Nature *)value)->i)); - return 0; + if (!BPy_Nature_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be a Nature"); + return -1; + } + self->vv->setNature(PyLong_AsLong((PyObject *)&((BPy_Nature *)value)->i)); + return 0; } static PyGetSetDef BPy_ViewVertex_getseters[] = { - {(char *)"nature", (getter)ViewVertex_nature_get, (setter)ViewVertex_nature_set, - (char *)ViewVertex_nature_doc, NULL}, - {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ + {(char *)"nature", + (getter)ViewVertex_nature_get, + (setter)ViewVertex_nature_set, + (char *)ViewVertex_nature_doc, + NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; /*-----------------------BPy_ViewVertex type definition ------------------------------*/ PyTypeObject ViewVertex_Type = { - PyVarObject_HEAD_INIT(NULL, 0) - "ViewVertex", /* tp_name */ - sizeof(BPy_ViewVertex), /* tp_basicsize */ - 0, /* tp_itemsize */ - 0, /* tp_dealloc */ - 0, /* tp_print */ - 0, /* tp_getattr */ - 0, /* tp_setattr */ - 0, /* tp_reserved */ - 0, /* tp_repr */ - 0, /* tp_as_number */ - 0, /* tp_as_sequence */ - 0, /* tp_as_mapping */ - 0, /* tp_hash */ - 0, /* tp_call */ - 0, /* tp_str */ - 0, /* tp_getattro */ - 0, /* tp_setattro */ - 0, /* tp_as_buffer */ - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ - ViewVertex_doc, /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ - 0, /* tp_iter */ - 0, /* tp_iternext */ - BPy_ViewVertex_methods, /* tp_methods */ - 0, /* tp_members */ - BPy_ViewVertex_getseters, /* tp_getset */ - &Interface0D_Type, /* tp_base */ - 0, /* tp_dict */ - 0, /* tp_descr_get */ - 0, /* tp_descr_set */ - 0, /* tp_dictoffset */ - (initproc)ViewVertex_init, /* tp_init */ - 0, /* tp_alloc */ - 0, /* tp_new */ + PyVarObject_HEAD_INIT(NULL, 0) "ViewVertex", /* tp_name */ + sizeof(BPy_ViewVertex), /* tp_basicsize */ + 0, /* tp_itemsize */ + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_reserved */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + ViewVertex_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + BPy_ViewVertex_methods, /* tp_methods */ + 0, /* tp_members */ + BPy_ViewVertex_getseters, /* tp_getset */ + &Interface0D_Type, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)ViewVertex_init, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ }; /////////////////////////////////////////////////////////////////////////////////////////// diff --git a/source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.h b/source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.h index 63bff6557fc..6769efa4673 100644 --- a/source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.h +++ b/source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.h @@ -37,8 +37,8 @@ extern PyTypeObject ViewVertex_Type; /*---------------------------Python BPy_ViewVertex structure definition----------*/ typedef struct { - BPy_Interface0D py_if0D; - ViewVertex *vv; + BPy_Interface0D py_if0D; + ViewVertex *vv; } BPy_ViewVertex; /////////////////////////////////////////////////////////////////////////////////////////// diff --git a/source/blender/freestyle/intern/python/Interface0D/CurvePoint/BPy_StrokeVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/CurvePoint/BPy_StrokeVertex.cpp index 0df055194ae..3637899fbc2 100644 --- a/source/blender/freestyle/intern/python/Interface0D/CurvePoint/BPy_StrokeVertex.cpp +++ b/source/blender/freestyle/intern/python/Interface0D/CurvePoint/BPy_StrokeVertex.cpp @@ -33,342 +33,381 @@ extern "C" { //------------------------INSTANCE METHODS ---------------------------------- -PyDoc_STRVAR(StrokeVertex_doc, -"Class hierarchy: :class:`Interface0D` > :class:`CurvePoint` > :class:`StrokeVertex`\n" -"\n" -"Class to define a stroke vertex.\n" -"\n" -".. method:: __init__()\n" -"\n" -" Default constructor.\n" -"\n" -".. method:: __init__(brother)\n" -"\n" -" Copy constructor.\n" -"\n" -" :arg brother: A StrokeVertex object.\n" -" :type brother: :class:`StrokeVertex`\n" -"\n" -".. method:: __init__(first_vertex, second_vertex, t3d)\n" -"\n" -" Build a stroke vertex from 2 stroke vertices and an interpolation\n" -" parameter.\n" -"\n" -" :arg first_vertex: The first StrokeVertex.\n" -" :type first_vertex: :class:`StrokeVertex`\n" -" :arg second_vertex: The second StrokeVertex.\n" -" :type second_vertex: :class:`StrokeVertex`\n" -" :arg t3d: An interpolation parameter.\n" -" :type t3d: float\n" -"\n" -".. method:: __init__(point)\n" -"\n" -" Build a stroke vertex from a CurvePoint\n" -"\n" -" :arg point: A CurvePoint object.\n" -" :type point: :class:`CurvePoint`\n" -"\n" -".. method:: __init__(svertex)\n" -"\n" -" Build a stroke vertex from a SVertex\n" -"\n" -" :arg svertex: An SVertex object.\n" -" :type svertex: :class:`SVertex`\n" -"\n" -".. method:: __init__(svertex, attribute)\n" -"\n" -" Build a stroke vertex from an SVertex and a StrokeAttribute object.\n" -"\n" -" :arg svertex: An SVertex object.\n" -" :type svertex: :class:`SVertex`\n" -" :arg attribute: A StrokeAttribute object.\n" -" :type attribute: :class:`StrokeAttribute`"); +PyDoc_STRVAR( + StrokeVertex_doc, + "Class hierarchy: :class:`Interface0D` > :class:`CurvePoint` > :class:`StrokeVertex`\n" + "\n" + "Class to define a stroke vertex.\n" + "\n" + ".. method:: __init__()\n" + "\n" + " Default constructor.\n" + "\n" + ".. method:: __init__(brother)\n" + "\n" + " Copy constructor.\n" + "\n" + " :arg brother: A StrokeVertex object.\n" + " :type brother: :class:`StrokeVertex`\n" + "\n" + ".. method:: __init__(first_vertex, second_vertex, t3d)\n" + "\n" + " Build a stroke vertex from 2 stroke vertices and an interpolation\n" + " parameter.\n" + "\n" + " :arg first_vertex: The first StrokeVertex.\n" + " :type first_vertex: :class:`StrokeVertex`\n" + " :arg second_vertex: The second StrokeVertex.\n" + " :type second_vertex: :class:`StrokeVertex`\n" + " :arg t3d: An interpolation parameter.\n" + " :type t3d: float\n" + "\n" + ".. method:: __init__(point)\n" + "\n" + " Build a stroke vertex from a CurvePoint\n" + "\n" + " :arg point: A CurvePoint object.\n" + " :type point: :class:`CurvePoint`\n" + "\n" + ".. method:: __init__(svertex)\n" + "\n" + " Build a stroke vertex from a SVertex\n" + "\n" + " :arg svertex: An SVertex object.\n" + " :type svertex: :class:`SVertex`\n" + "\n" + ".. method:: __init__(svertex, attribute)\n" + "\n" + " Build a stroke vertex from an SVertex and a StrokeAttribute object.\n" + "\n" + " :arg svertex: An SVertex object.\n" + " :type svertex: :class:`SVertex`\n" + " :arg attribute: A StrokeAttribute object.\n" + " :type attribute: :class:`StrokeAttribute`"); static int StrokeVertex_init(BPy_StrokeVertex *self, PyObject *args, PyObject *kwds) { - static const char *kwlist_1[] = {"brother", NULL}; - static const char *kwlist_2[] = {"first_vertex", "second_vertex", "t3d", NULL}; - static const char *kwlist_3[] = {"point", NULL}; - static const char *kwlist_4[] = {"svertex", "attribute", NULL}; - PyObject *obj1 = 0, *obj2 = 0; - float t3d; - - if (PyArg_ParseTupleAndKeywords(args, kwds, "|O!", (char **)kwlist_1, &StrokeVertex_Type, &obj1)) { - if (!obj1) { - self->sv = new StrokeVertex(); - } - else { - if (!((BPy_StrokeVertex *)obj1)->sv) { - PyErr_SetString(PyExc_TypeError, "argument 1 is an invalid StrokeVertex object"); - return -1; - } - self->sv = new StrokeVertex(*(((BPy_StrokeVertex *)obj1)->sv)); - } - } - else if (PyErr_Clear(), - PyArg_ParseTupleAndKeywords(args, kwds, "O!O!f", (char **)kwlist_2, - &StrokeVertex_Type, &obj1, &StrokeVertex_Type, &obj2, &t3d)) - { - StrokeVertex *sv1 = ((BPy_StrokeVertex *)obj1)->sv; - StrokeVertex *sv2 = ((BPy_StrokeVertex *)obj2)->sv; - if (!sv1 || (sv1->A() == 0 && sv1->B() == 0)) { - PyErr_SetString(PyExc_TypeError, "argument 1 is an invalid StrokeVertex object"); - return -1; - } - if (!sv2 || (sv2->A() == 0 && sv2->B() == 0)) { - PyErr_SetString(PyExc_TypeError, "argument 2 is an invalid StrokeVertex object"); - return -1; - } - self->sv = new StrokeVertex(sv1, sv2, t3d); - } - else if (PyErr_Clear(), - PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist_3, &CurvePoint_Type, &obj1)) - { - CurvePoint *cp = ((BPy_CurvePoint *)obj1)->cp; - if (!cp || cp->A() == 0 || cp->B() == 0) { - PyErr_SetString(PyExc_TypeError, "argument 1 is an invalid CurvePoint object"); - return -1; - } - self->sv = new StrokeVertex(cp); - } - else if (PyErr_Clear(), (obj2 = 0), - PyArg_ParseTupleAndKeywords(args, kwds, "O!|O!", (char **)kwlist_4, - &SVertex_Type, &obj1, &StrokeAttribute_Type, &obj2)) - { - if (!obj2) - self->sv = new StrokeVertex(((BPy_SVertex *)obj1)->sv); - else - self->sv = new StrokeVertex(((BPy_SVertex *)obj1)->sv, *(((BPy_StrokeAttribute *)obj2)->sa)); - } - else { - PyErr_SetString(PyExc_TypeError, "invalid argument(s)"); - return -1; - } - self->py_cp.cp = self->sv; - self->py_cp.py_if0D.if0D = self->sv; - self->py_cp.py_if0D.borrowed = false; - return 0; + static const char *kwlist_1[] = {"brother", NULL}; + static const char *kwlist_2[] = {"first_vertex", "second_vertex", "t3d", NULL}; + static const char *kwlist_3[] = {"point", NULL}; + static const char *kwlist_4[] = {"svertex", "attribute", NULL}; + PyObject *obj1 = 0, *obj2 = 0; + float t3d; + + if (PyArg_ParseTupleAndKeywords( + args, kwds, "|O!", (char **)kwlist_1, &StrokeVertex_Type, &obj1)) { + if (!obj1) { + self->sv = new StrokeVertex(); + } + else { + if (!((BPy_StrokeVertex *)obj1)->sv) { + PyErr_SetString(PyExc_TypeError, "argument 1 is an invalid StrokeVertex object"); + return -1; + } + self->sv = new StrokeVertex(*(((BPy_StrokeVertex *)obj1)->sv)); + } + } + else if (PyErr_Clear(), + PyArg_ParseTupleAndKeywords(args, + kwds, + "O!O!f", + (char **)kwlist_2, + &StrokeVertex_Type, + &obj1, + &StrokeVertex_Type, + &obj2, + &t3d)) { + StrokeVertex *sv1 = ((BPy_StrokeVertex *)obj1)->sv; + StrokeVertex *sv2 = ((BPy_StrokeVertex *)obj2)->sv; + if (!sv1 || (sv1->A() == 0 && sv1->B() == 0)) { + PyErr_SetString(PyExc_TypeError, "argument 1 is an invalid StrokeVertex object"); + return -1; + } + if (!sv2 || (sv2->A() == 0 && sv2->B() == 0)) { + PyErr_SetString(PyExc_TypeError, "argument 2 is an invalid StrokeVertex object"); + return -1; + } + self->sv = new StrokeVertex(sv1, sv2, t3d); + } + else if (PyErr_Clear(), + PyArg_ParseTupleAndKeywords( + args, kwds, "O!", (char **)kwlist_3, &CurvePoint_Type, &obj1)) { + CurvePoint *cp = ((BPy_CurvePoint *)obj1)->cp; + if (!cp || cp->A() == 0 || cp->B() == 0) { + PyErr_SetString(PyExc_TypeError, "argument 1 is an invalid CurvePoint object"); + return -1; + } + self->sv = new StrokeVertex(cp); + } + else if (PyErr_Clear(), + (obj2 = 0), + PyArg_ParseTupleAndKeywords(args, + kwds, + "O!|O!", + (char **)kwlist_4, + &SVertex_Type, + &obj1, + &StrokeAttribute_Type, + &obj2)) { + if (!obj2) + self->sv = new StrokeVertex(((BPy_SVertex *)obj1)->sv); + else + self->sv = new StrokeVertex(((BPy_SVertex *)obj1)->sv, *(((BPy_StrokeAttribute *)obj2)->sa)); + } + else { + PyErr_SetString(PyExc_TypeError, "invalid argument(s)"); + return -1; + } + self->py_cp.cp = self->sv; + self->py_cp.py_if0D.if0D = self->sv; + self->py_cp.py_if0D.borrowed = false; + return 0; } -// real operator[] (const int i) const -// real & operator[] (const int i) +// real operator[] (const int i) const +// real & operator[] (const int i) /*----------------------mathutils callbacks ----------------------------*/ static int StrokeVertex_mathutils_check(BaseMathObject *bmo) { - if (!BPy_StrokeVertex_Check(bmo->cb_user)) - return -1; - return 0; + if (!BPy_StrokeVertex_Check(bmo->cb_user)) + return -1; + return 0; } static int StrokeVertex_mathutils_get(BaseMathObject *bmo, int /*subtype*/) { - BPy_StrokeVertex *self = (BPy_StrokeVertex *)bmo->cb_user; - bmo->data[0] = (float)self->sv->x(); - bmo->data[1] = (float)self->sv->y(); - return 0; + BPy_StrokeVertex *self = (BPy_StrokeVertex *)bmo->cb_user; + bmo->data[0] = (float)self->sv->x(); + bmo->data[1] = (float)self->sv->y(); + return 0; } static int StrokeVertex_mathutils_set(BaseMathObject *bmo, int /*subtype*/) { - BPy_StrokeVertex *self = (BPy_StrokeVertex *)bmo->cb_user; - self->sv->setX((real)bmo->data[0]); - self->sv->setY((real)bmo->data[1]); - return 0; + BPy_StrokeVertex *self = (BPy_StrokeVertex *)bmo->cb_user; + self->sv->setX((real)bmo->data[0]); + self->sv->setY((real)bmo->data[1]); + return 0; } static int StrokeVertex_mathutils_get_index(BaseMathObject *bmo, int /*subtype*/, int index) { - BPy_StrokeVertex *self = (BPy_StrokeVertex *)bmo->cb_user; - switch (index) { - case 0: bmo->data[0] = (float)self->sv->x(); break; - case 1: bmo->data[1] = (float)self->sv->y(); break; - default: - return -1; - } - return 0; + BPy_StrokeVertex *self = (BPy_StrokeVertex *)bmo->cb_user; + switch (index) { + case 0: + bmo->data[0] = (float)self->sv->x(); + break; + case 1: + bmo->data[1] = (float)self->sv->y(); + break; + default: + return -1; + } + return 0; } static int StrokeVertex_mathutils_set_index(BaseMathObject *bmo, int /*subtype*/, int index) { - BPy_StrokeVertex *self = (BPy_StrokeVertex *)bmo->cb_user; - switch (index) { - case 0: self->sv->setX((real)bmo->data[0]); break; - case 1: self->sv->setY((real)bmo->data[1]); break; - default: - return -1; - } - return 0; + BPy_StrokeVertex *self = (BPy_StrokeVertex *)bmo->cb_user; + switch (index) { + case 0: + self->sv->setX((real)bmo->data[0]); + break; + case 1: + self->sv->setY((real)bmo->data[1]); + break; + default: + return -1; + } + return 0; } static Mathutils_Callback StrokeVertex_mathutils_cb = { - StrokeVertex_mathutils_check, - StrokeVertex_mathutils_get, - StrokeVertex_mathutils_set, - StrokeVertex_mathutils_get_index, - StrokeVertex_mathutils_set_index, + StrokeVertex_mathutils_check, + StrokeVertex_mathutils_get, + StrokeVertex_mathutils_set, + StrokeVertex_mathutils_get_index, + StrokeVertex_mathutils_set_index, }; static unsigned char StrokeVertex_mathutils_cb_index = -1; void StrokeVertex_mathutils_register_callback() { - StrokeVertex_mathutils_cb_index = Mathutils_RegisterCallback(&StrokeVertex_mathutils_cb); + StrokeVertex_mathutils_cb_index = Mathutils_RegisterCallback(&StrokeVertex_mathutils_cb); } /*----------------------StrokeVertex get/setters ----------------------------*/ PyDoc_STRVAR(StrokeVertex_attribute_doc, -"StrokeAttribute for this StrokeVertex.\n" -"\n" -":type: :class:`StrokeAttribute`"); + "StrokeAttribute for this StrokeVertex.\n" + "\n" + ":type: :class:`StrokeAttribute`"); static PyObject *StrokeVertex_attribute_get(BPy_StrokeVertex *self, void *UNUSED(closure)) { - return BPy_StrokeAttribute_from_StrokeAttribute(self->sv->attribute()); + return BPy_StrokeAttribute_from_StrokeAttribute(self->sv->attribute()); } -static int StrokeVertex_attribute_set(BPy_StrokeVertex *self, PyObject *value, void *UNUSED(closure)) +static int StrokeVertex_attribute_set(BPy_StrokeVertex *self, + PyObject *value, + void *UNUSED(closure)) { - if (!BPy_StrokeAttribute_Check(value)) { - PyErr_SetString(PyExc_TypeError, "value must be a StrokeAttribute object"); - return -1; - } - self->sv->setAttribute(*(((BPy_StrokeAttribute *)value)->sa)); - return 0; + if (!BPy_StrokeAttribute_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be a StrokeAttribute object"); + return -1; + } + self->sv->setAttribute(*(((BPy_StrokeAttribute *)value)->sa)); + return 0; } PyDoc_STRVAR(StrokeVertex_curvilinear_abscissa_doc, -"Curvilinear abscissa of this StrokeVertex in the Stroke.\n" -"\n" -":type: float"); + "Curvilinear abscissa of this StrokeVertex in the Stroke.\n" + "\n" + ":type: float"); -static PyObject *StrokeVertex_curvilinear_abscissa_get(BPy_StrokeVertex *self, void *UNUSED(closure)) +static PyObject *StrokeVertex_curvilinear_abscissa_get(BPy_StrokeVertex *self, + void *UNUSED(closure)) { - return PyFloat_FromDouble(self->sv->curvilinearAbscissa()); + return PyFloat_FromDouble(self->sv->curvilinearAbscissa()); } -static int StrokeVertex_curvilinear_abscissa_set(BPy_StrokeVertex *self, PyObject *value, void *UNUSED(closure)) +static int StrokeVertex_curvilinear_abscissa_set(BPy_StrokeVertex *self, + PyObject *value, + void *UNUSED(closure)) { - float scalar; - if ((scalar = PyFloat_AsDouble(value)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */ - PyErr_SetString(PyExc_TypeError, "value must be a number"); - return -1; - } - self->sv->setCurvilinearAbscissa(scalar); - return 0; + float scalar; + if ((scalar = PyFloat_AsDouble(value)) == -1.0f && + PyErr_Occurred()) { /* parsed item not a number */ + PyErr_SetString(PyExc_TypeError, "value must be a number"); + return -1; + } + self->sv->setCurvilinearAbscissa(scalar); + return 0; } PyDoc_STRVAR(StrokeVertex_point_doc, -"2D point coordinates.\n" -"\n" -":type: :class:`mathutils.Vector`"); + "2D point coordinates.\n" + "\n" + ":type: :class:`mathutils.Vector`"); static PyObject *StrokeVertex_point_get(BPy_StrokeVertex *self, void *UNUSED(closure)) { - return Vector_CreatePyObject_cb((PyObject *)self, 2, StrokeVertex_mathutils_cb_index, 0); + return Vector_CreatePyObject_cb((PyObject *)self, 2, StrokeVertex_mathutils_cb_index, 0); } static int StrokeVertex_point_set(BPy_StrokeVertex *self, PyObject *value, void *UNUSED(closure)) { - float v[2]; - if (mathutils_array_parse(v, 2, 2, value, - "value must be a 2-dimensional vector") == -1) - { - return -1; - } - self->sv->setX(v[0]); - self->sv->setY(v[1]); - return 0; + float v[2]; + if (mathutils_array_parse(v, 2, 2, value, "value must be a 2-dimensional vector") == -1) { + return -1; + } + self->sv->setX(v[0]); + self->sv->setY(v[1]); + return 0; } PyDoc_STRVAR(StrokeVertex_stroke_length_doc, -"Stroke length (it is only a value retained by the StrokeVertex,\n" -"and it won't change the real stroke length).\n" -"\n" -":type: float"); + "Stroke length (it is only a value retained by the StrokeVertex,\n" + "and it won't change the real stroke length).\n" + "\n" + ":type: float"); static PyObject *StrokeVertex_stroke_length_get(BPy_StrokeVertex *self, void *UNUSED(closure)) { - return PyFloat_FromDouble(self->sv->strokeLength()); + return PyFloat_FromDouble(self->sv->strokeLength()); } -static int StrokeVertex_stroke_length_set(BPy_StrokeVertex *self, PyObject *value, void *UNUSED(closure)) +static int StrokeVertex_stroke_length_set(BPy_StrokeVertex *self, + PyObject *value, + void *UNUSED(closure)) { - float scalar; - if ((scalar = PyFloat_AsDouble(value)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */ - PyErr_SetString(PyExc_TypeError, "value must be a number"); - return -1; - } - self->sv->setStrokeLength(scalar); - return 0; + float scalar; + if ((scalar = PyFloat_AsDouble(value)) == -1.0f && + PyErr_Occurred()) { /* parsed item not a number */ + PyErr_SetString(PyExc_TypeError, "value must be a number"); + return -1; + } + self->sv->setStrokeLength(scalar); + return 0; } PyDoc_STRVAR(StrokeVertex_u_doc, -"Curvilinear abscissa of this StrokeVertex in the Stroke.\n" -"\n" -":type: float"); + "Curvilinear abscissa of this StrokeVertex in the Stroke.\n" + "\n" + ":type: float"); static PyObject *StrokeVertex_u_get(BPy_StrokeVertex *self, void *UNUSED(closure)) { - return PyFloat_FromDouble(self->sv->u()); + return PyFloat_FromDouble(self->sv->u()); } static PyGetSetDef BPy_StrokeVertex_getseters[] = { - {(char *)"attribute", (getter)StrokeVertex_attribute_get, (setter)StrokeVertex_attribute_set, - (char *)StrokeVertex_attribute_doc, NULL}, - {(char *)"curvilinear_abscissa", (getter)StrokeVertex_curvilinear_abscissa_get, - (setter)StrokeVertex_curvilinear_abscissa_set, - (char *)StrokeVertex_curvilinear_abscissa_doc, NULL}, - {(char *)"point", (getter)StrokeVertex_point_get, (setter)StrokeVertex_point_set, - (char *)StrokeVertex_point_doc, NULL}, - {(char *)"stroke_length", (getter)StrokeVertex_stroke_length_get, (setter)StrokeVertex_stroke_length_set, - (char *)StrokeVertex_stroke_length_doc, NULL}, - {(char *)"u", (getter)StrokeVertex_u_get, (setter)NULL, (char *)StrokeVertex_u_doc, NULL}, - {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ + {(char *)"attribute", + (getter)StrokeVertex_attribute_get, + (setter)StrokeVertex_attribute_set, + (char *)StrokeVertex_attribute_doc, + NULL}, + {(char *)"curvilinear_abscissa", + (getter)StrokeVertex_curvilinear_abscissa_get, + (setter)StrokeVertex_curvilinear_abscissa_set, + (char *)StrokeVertex_curvilinear_abscissa_doc, + NULL}, + {(char *)"point", + (getter)StrokeVertex_point_get, + (setter)StrokeVertex_point_set, + (char *)StrokeVertex_point_doc, + NULL}, + {(char *)"stroke_length", + (getter)StrokeVertex_stroke_length_get, + (setter)StrokeVertex_stroke_length_set, + (char *)StrokeVertex_stroke_length_doc, + NULL}, + {(char *)"u", (getter)StrokeVertex_u_get, (setter)NULL, (char *)StrokeVertex_u_doc, NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; /*-----------------------BPy_StrokeVertex type definition ------------------------------*/ PyTypeObject StrokeVertex_Type = { - PyVarObject_HEAD_INIT(NULL, 0) - "StrokeVertex", /* tp_name */ - sizeof(BPy_StrokeVertex), /* tp_basicsize */ - 0, /* tp_itemsize */ - 0, /* tp_dealloc */ - 0, /* tp_print */ - 0, /* tp_getattr */ - 0, /* tp_setattr */ - 0, /* tp_reserved */ - 0, /* tp_repr */ - 0, /* tp_as_number */ - 0, /* tp_as_sequence */ - 0, /* tp_as_mapping */ - 0, /* tp_hash */ - 0, /* tp_call */ - 0, /* tp_str */ - 0, /* tp_getattro */ - 0, /* tp_setattro */ - 0, /* tp_as_buffer */ - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ - StrokeVertex_doc, /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ - 0, /* tp_iter */ - 0, /* tp_iternext */ - 0, /* tp_methods */ - 0, /* tp_members */ - BPy_StrokeVertex_getseters, /* tp_getset */ - &CurvePoint_Type, /* tp_base */ - 0, /* tp_dict */ - 0, /* tp_descr_get */ - 0, /* tp_descr_set */ - 0, /* tp_dictoffset */ - (initproc)StrokeVertex_init, /* tp_init */ - 0, /* tp_alloc */ - 0, /* tp_new */ + PyVarObject_HEAD_INIT(NULL, 0) "StrokeVertex", /* tp_name */ + sizeof(BPy_StrokeVertex), /* tp_basicsize */ + 0, /* tp_itemsize */ + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_reserved */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + StrokeVertex_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + BPy_StrokeVertex_getseters, /* tp_getset */ + &CurvePoint_Type, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)StrokeVertex_init, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ }; /////////////////////////////////////////////////////////////////////////////////////////// diff --git a/source/blender/freestyle/intern/python/Interface0D/CurvePoint/BPy_StrokeVertex.h b/source/blender/freestyle/intern/python/Interface0D/CurvePoint/BPy_StrokeVertex.h index a7bbae59c38..e2eab6ab887 100644 --- a/source/blender/freestyle/intern/python/Interface0D/CurvePoint/BPy_StrokeVertex.h +++ b/source/blender/freestyle/intern/python/Interface0D/CurvePoint/BPy_StrokeVertex.h @@ -33,12 +33,13 @@ extern "C" { extern PyTypeObject StrokeVertex_Type; -#define BPy_StrokeVertex_Check(v) (PyObject_IsInstance((PyObject *)v, (PyObject *)&StrokeVertex_Type)) +#define BPy_StrokeVertex_Check(v) \ + (PyObject_IsInstance((PyObject *)v, (PyObject *)&StrokeVertex_Type)) /*---------------------------Python BPy_StrokeVertex structure definition----------*/ typedef struct { - BPy_CurvePoint py_cp; - StrokeVertex *sv; + BPy_CurvePoint py_cp; + StrokeVertex *sv; } BPy_StrokeVertex; /*---------------------------Python BPy_StrokeVertex visible prototypes-----------*/ diff --git a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.cpp index 49a1e7cc8b3..87873677189 100644 --- a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.cpp +++ b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.cpp @@ -32,112 +32,114 @@ extern "C" { /*----------------------NonTVertex methods ----------------------------*/ PyDoc_STRVAR(NonTVertex_doc, -"Class hierarchy: :class:`Interface0D` > :class:`ViewVertex` > :class:`NonTVertex`\n" -"\n" -"View vertex for corners, cusps, etc. associated to a single SVertex.\n" -"Can be associated to 2 or more view edges.\n" -"\n" -".. method:: __init__()\n" -"\n" -" Default constructor.\n" -"\n" -".. method:: __init__(svertex)\n" -"\n" -" Build a NonTVertex from a SVertex.\n" -"\n" -" :arg svertex: An SVertex object.\n" -" :type svertex: :class:`SVertex`"); + "Class hierarchy: :class:`Interface0D` > :class:`ViewVertex` > :class:`NonTVertex`\n" + "\n" + "View vertex for corners, cusps, etc. associated to a single SVertex.\n" + "Can be associated to 2 or more view edges.\n" + "\n" + ".. method:: __init__()\n" + "\n" + " Default constructor.\n" + "\n" + ".. method:: __init__(svertex)\n" + "\n" + " Build a NonTVertex from a SVertex.\n" + "\n" + " :arg svertex: An SVertex object.\n" + " :type svertex: :class:`SVertex`"); /* Note: No copy constructor in Python because the C++ copy constructor is 'protected'. */ static int NonTVertex_init(BPy_NonTVertex *self, PyObject *args, PyObject *kwds) { - static const char *kwlist[] = {"svertex", NULL}; - PyObject *obj = 0; - - if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O!", (char **)kwlist, &SVertex_Type, &obj)) - return -1; - if (!obj) - self->ntv = new NonTVertex(); - else - self->ntv = new NonTVertex(((BPy_SVertex *)obj)->sv); - self->py_vv.vv = self->ntv; - self->py_vv.py_if0D.if0D = self->ntv; - self->py_vv.py_if0D.borrowed = false; - return 0; + static const char *kwlist[] = {"svertex", NULL}; + PyObject *obj = 0; + + if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O!", (char **)kwlist, &SVertex_Type, &obj)) + return -1; + if (!obj) + self->ntv = new NonTVertex(); + else + self->ntv = new NonTVertex(((BPy_SVertex *)obj)->sv); + self->py_vv.vv = self->ntv; + self->py_vv.py_if0D.if0D = self->ntv; + self->py_vv.py_if0D.borrowed = false; + return 0; } /*----------------------NonTVertex get/setters ----------------------------*/ PyDoc_STRVAR(NonTVertex_svertex_doc, -"The SVertex on top of which this NonTVertex is built.\n" -"\n" -":type: :class:`SVertex`"); + "The SVertex on top of which this NonTVertex is built.\n" + "\n" + ":type: :class:`SVertex`"); static PyObject *NonTVertex_svertex_get(BPy_NonTVertex *self, void *UNUSED(closure)) { - SVertex *v = self->ntv->svertex(); - if (v) - return BPy_SVertex_from_SVertex(*v); - Py_RETURN_NONE; + SVertex *v = self->ntv->svertex(); + if (v) + return BPy_SVertex_from_SVertex(*v); + Py_RETURN_NONE; } static int NonTVertex_svertex_set(BPy_NonTVertex *self, PyObject *value, void *UNUSED(closure)) { - if (!BPy_SVertex_Check(value)) { - PyErr_SetString(PyExc_TypeError, "value must be an SVertex"); - return -1; - } - self->ntv->setSVertex(((BPy_SVertex *)value)->sv); - return 0; + if (!BPy_SVertex_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be an SVertex"); + return -1; + } + self->ntv->setSVertex(((BPy_SVertex *)value)->sv); + return 0; } static PyGetSetDef BPy_NonTVertex_getseters[] = { - {(char *)"svertex", (getter)NonTVertex_svertex_get, (setter)NonTVertex_svertex_set, - (char *)NonTVertex_svertex_doc, NULL}, - {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ + {(char *)"svertex", + (getter)NonTVertex_svertex_get, + (setter)NonTVertex_svertex_set, + (char *)NonTVertex_svertex_doc, + NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; /*-----------------------BPy_NonTVertex type definition ------------------------------*/ PyTypeObject NonTVertex_Type = { - PyVarObject_HEAD_INIT(NULL, 0) - "NonTVertex", /* tp_name */ - sizeof(BPy_NonTVertex), /* tp_basicsize */ - 0, /* tp_itemsize */ - 0, /* tp_dealloc */ - 0, /* tp_print */ - 0, /* tp_getattr */ - 0, /* tp_setattr */ - 0, /* tp_reserved */ - 0, /* tp_repr */ - 0, /* tp_as_number */ - 0, /* tp_as_sequence */ - 0, /* tp_as_mapping */ - 0, /* tp_hash */ - 0, /* tp_call */ - 0, /* tp_str */ - 0, /* tp_getattro */ - 0, /* tp_setattro */ - 0, /* tp_as_buffer */ - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ - NonTVertex_doc, /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ - 0, /* tp_iter */ - 0, /* tp_iternext */ - 0, /* tp_methods */ - 0, /* tp_members */ - BPy_NonTVertex_getseters, /* tp_getset */ - &ViewVertex_Type, /* tp_base */ - 0, /* tp_dict */ - 0, /* tp_descr_get */ - 0, /* tp_descr_set */ - 0, /* tp_dictoffset */ - (initproc)NonTVertex_init, /* tp_init */ - 0, /* tp_alloc */ - 0, /* tp_new */ + PyVarObject_HEAD_INIT(NULL, 0) "NonTVertex", /* tp_name */ + sizeof(BPy_NonTVertex), /* tp_basicsize */ + 0, /* tp_itemsize */ + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_reserved */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + NonTVertex_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + BPy_NonTVertex_getseters, /* tp_getset */ + &ViewVertex_Type, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)NonTVertex_init, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ }; /////////////////////////////////////////////////////////////////////////////////////////// diff --git a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.h b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.h index fc65dd3eb0f..fdea985a125 100644 --- a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.h +++ b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.h @@ -37,8 +37,8 @@ extern PyTypeObject NonTVertex_Type; /*---------------------------Python BPy_NonTVertex structure definition----------*/ typedef struct { - BPy_ViewVertex py_vv; - NonTVertex *ntv; + BPy_ViewVertex py_vv; + NonTVertex *ntv; } BPy_NonTVertex; /////////////////////////////////////////////////////////////////////////////////////////// diff --git a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp index f24d551fad8..9a8592aaea5 100644 --- a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp +++ b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp @@ -35,205 +35,216 @@ extern "C" { /*----------------------TVertex methods ----------------------------*/ PyDoc_STRVAR(TVertex_doc, -"Class hierarchy: :class:`Interface0D` > :class:`ViewVertex` > :class:`TVertex`\n" -"\n" -"Class to define a T vertex, i.e. an intersection between two edges.\n" -"It points towards two SVertex and four ViewEdges. Among the\n" -"ViewEdges, two are front and the other two are back. Basically a\n" -"front edge hides part of a back edge. So, among the back edges, one\n" -"is of invisibility N and the other of invisibility N+1.\n" -"\n" -".. method:: __init__()\n" -"\n" -" Default constructor."); + "Class hierarchy: :class:`Interface0D` > :class:`ViewVertex` > :class:`TVertex`\n" + "\n" + "Class to define a T vertex, i.e. an intersection between two edges.\n" + "It points towards two SVertex and four ViewEdges. Among the\n" + "ViewEdges, two are front and the other two are back. Basically a\n" + "front edge hides part of a back edge. So, among the back edges, one\n" + "is of invisibility N and the other of invisibility N+1.\n" + "\n" + ".. method:: __init__()\n" + "\n" + " Default constructor."); /* Note: No copy constructor in Python because the C++ copy constructor is 'protected'. */ static int TVertex_init(BPy_TVertex *self, PyObject *args, PyObject *kwds) { - static const char *kwlist[] = {NULL}; - - if (!PyArg_ParseTupleAndKeywords(args, kwds, "", (char **)kwlist)) - return -1; - self->tv = new TVertex(); - self->py_vv.vv = self->tv; - self->py_vv.py_if0D.if0D = self->tv; - self->py_vv.py_if0D.borrowed = false; - return 0; + static const char *kwlist[] = {NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwds, "", (char **)kwlist)) + return -1; + self->tv = new TVertex(); + self->py_vv.vv = self->tv; + self->py_vv.py_if0D.if0D = self->tv; + self->py_vv.py_if0D.borrowed = false; + return 0; } PyDoc_STRVAR(TVertex_get_svertex_doc, -".. method:: get_svertex(fedge)\n" -"\n" -" Returns the SVertex (among the 2) belonging to the given FEdge.\n" -"\n" -" :arg fedge: An FEdge object.\n" -" :type fedge: :class:`FEdge`\n" -" :return: The SVertex belonging to the given FEdge.\n" -" :rtype: :class:`SVertex`"); - -static PyObject *TVertex_get_svertex( BPy_TVertex *self, PyObject *args, PyObject *kwds) + ".. method:: get_svertex(fedge)\n" + "\n" + " Returns the SVertex (among the 2) belonging to the given FEdge.\n" + "\n" + " :arg fedge: An FEdge object.\n" + " :type fedge: :class:`FEdge`\n" + " :return: The SVertex belonging to the given FEdge.\n" + " :rtype: :class:`SVertex`"); + +static PyObject *TVertex_get_svertex(BPy_TVertex *self, PyObject *args, PyObject *kwds) { - static const char *kwlist[] = {"fedge", NULL}; - PyObject *py_fe; - - if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &FEdge_Type, &py_fe)) - return NULL; - SVertex *sv = self->tv->getSVertex(((BPy_FEdge *)py_fe)->fe); - if (sv) - return BPy_SVertex_from_SVertex(*sv); - Py_RETURN_NONE; + static const char *kwlist[] = {"fedge", NULL}; + PyObject *py_fe; + + if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &FEdge_Type, &py_fe)) + return NULL; + SVertex *sv = self->tv->getSVertex(((BPy_FEdge *)py_fe)->fe); + if (sv) + return BPy_SVertex_from_SVertex(*sv); + Py_RETURN_NONE; } PyDoc_STRVAR(TVertex_get_mate_doc, -".. method:: get_mate(viewedge)\n" -"\n" -" Returns the mate edge of the ViewEdge given as argument. If the\n" -" ViewEdge is frontEdgeA, frontEdgeB is returned. If the ViewEdge is\n" -" frontEdgeB, frontEdgeA is returned. Same for back edges.\n" -"\n" -" :arg viewedge: A ViewEdge object.\n" -" :type viewedge: :class:`ViewEdge`\n" -" :return: The mate edge of the given ViewEdge.\n" -" :rtype: :class:`ViewEdge`"); - -static PyObject *TVertex_get_mate( BPy_TVertex *self, PyObject *args, PyObject *kwds) + ".. method:: get_mate(viewedge)\n" + "\n" + " Returns the mate edge of the ViewEdge given as argument. If the\n" + " ViewEdge is frontEdgeA, frontEdgeB is returned. If the ViewEdge is\n" + " frontEdgeB, frontEdgeA is returned. Same for back edges.\n" + "\n" + " :arg viewedge: A ViewEdge object.\n" + " :type viewedge: :class:`ViewEdge`\n" + " :return: The mate edge of the given ViewEdge.\n" + " :rtype: :class:`ViewEdge`"); + +static PyObject *TVertex_get_mate(BPy_TVertex *self, PyObject *args, PyObject *kwds) { - static const char *kwlist[] = {"viewedge", NULL}; - PyObject *py_ve; - - if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &ViewEdge_Type, &py_ve)) - return NULL; - ViewEdge *ve = self->tv->mate(((BPy_ViewEdge *)py_ve)->ve); - if (ve) - return BPy_ViewEdge_from_ViewEdge(*ve); - Py_RETURN_NONE; + static const char *kwlist[] = {"viewedge", NULL}; + PyObject *py_ve; + + if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &ViewEdge_Type, &py_ve)) + return NULL; + ViewEdge *ve = self->tv->mate(((BPy_ViewEdge *)py_ve)->ve); + if (ve) + return BPy_ViewEdge_from_ViewEdge(*ve); + Py_RETURN_NONE; } static PyMethodDef BPy_TVertex_methods[] = { - {"get_svertex", (PyCFunction)TVertex_get_svertex, METH_VARARGS | METH_KEYWORDS, TVertex_get_svertex_doc}, - {"get_mate", (PyCFunction)TVertex_get_mate, METH_VARARGS | METH_KEYWORDS, TVertex_get_mate_doc}, - {NULL, NULL, 0, NULL}, + {"get_svertex", + (PyCFunction)TVertex_get_svertex, + METH_VARARGS | METH_KEYWORDS, + TVertex_get_svertex_doc}, + {"get_mate", + (PyCFunction)TVertex_get_mate, + METH_VARARGS | METH_KEYWORDS, + TVertex_get_mate_doc}, + {NULL, NULL, 0, NULL}, }; /*----------------------TVertex get/setters ----------------------------*/ PyDoc_STRVAR(TVertex_front_svertex_doc, -"The SVertex that is closer to the viewpoint.\n" -"\n" -":type: :class:`SVertex`"); + "The SVertex that is closer to the viewpoint.\n" + "\n" + ":type: :class:`SVertex`"); static PyObject *TVertex_front_svertex_get(BPy_TVertex *self, void *UNUSED(closure)) { - SVertex *v = self->tv->frontSVertex(); - if (v) - return BPy_SVertex_from_SVertex(*v); - Py_RETURN_NONE; + SVertex *v = self->tv->frontSVertex(); + if (v) + return BPy_SVertex_from_SVertex(*v); + Py_RETURN_NONE; } static int TVertex_front_svertex_set(BPy_TVertex *self, PyObject *value, void *UNUSED(closure)) { - if (!BPy_SVertex_Check(value)) { - PyErr_SetString(PyExc_TypeError, "value must be an SVertex"); - return -1; - } - self->tv->setFrontSVertex(((BPy_SVertex *)value)->sv); - return 0; + if (!BPy_SVertex_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be an SVertex"); + return -1; + } + self->tv->setFrontSVertex(((BPy_SVertex *)value)->sv); + return 0; } PyDoc_STRVAR(TVertex_back_svertex_doc, -"The SVertex that is further away from the viewpoint.\n" -"\n" -":type: :class:`SVertex`"); + "The SVertex that is further away from the viewpoint.\n" + "\n" + ":type: :class:`SVertex`"); static PyObject *TVertex_back_svertex_get(BPy_TVertex *self, void *UNUSED(closure)) { - SVertex *v = self->tv->backSVertex(); - if (v) - return BPy_SVertex_from_SVertex(*v); - Py_RETURN_NONE; + SVertex *v = self->tv->backSVertex(); + if (v) + return BPy_SVertex_from_SVertex(*v); + Py_RETURN_NONE; } static int TVertex_back_svertex_set(BPy_TVertex *self, PyObject *value, void *UNUSED(closure)) { - if (!BPy_SVertex_Check(value)) { - PyErr_SetString(PyExc_TypeError, "value must be an SVertex"); - return -1; - } - self->tv->setBackSVertex(((BPy_SVertex *)value)->sv); - return 0; + if (!BPy_SVertex_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be an SVertex"); + return -1; + } + self->tv->setBackSVertex(((BPy_SVertex *)value)->sv); + return 0; } PyDoc_STRVAR(TVertex_id_doc, -"The Id of this TVertex.\n" -"\n" -":type: :class:`Id`"); + "The Id of this TVertex.\n" + "\n" + ":type: :class:`Id`"); static PyObject *TVertex_id_get(BPy_TVertex *self, void *UNUSED(closure)) { - Id id(self->tv->getId()); - return BPy_Id_from_Id(id); // return a copy + Id id(self->tv->getId()); + return BPy_Id_from_Id(id); // return a copy } static int TVertex_id_set(BPy_TVertex *self, PyObject *value, void *UNUSED(closure)) { - if (!BPy_Id_Check(value)) { - PyErr_SetString(PyExc_TypeError, "value must be an Id"); - return -1; - } - self->tv->setId(*(((BPy_Id *)value)->id)); - return 0; + if (!BPy_Id_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be an Id"); + return -1; + } + self->tv->setId(*(((BPy_Id *)value)->id)); + return 0; } static PyGetSetDef BPy_TVertex_getseters[] = { - {(char *)"front_svertex", (getter)TVertex_front_svertex_get, (setter)TVertex_front_svertex_set, - (char *)TVertex_front_svertex_doc, NULL}, - {(char *)"back_svertex", (getter)TVertex_back_svertex_get, (setter)TVertex_back_svertex_set, - (char *)TVertex_back_svertex_doc, NULL}, - {(char *)"id", (getter)TVertex_id_get, (setter)TVertex_id_set, (char *)TVertex_id_doc, NULL}, - {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ + {(char *)"front_svertex", + (getter)TVertex_front_svertex_get, + (setter)TVertex_front_svertex_set, + (char *)TVertex_front_svertex_doc, + NULL}, + {(char *)"back_svertex", + (getter)TVertex_back_svertex_get, + (setter)TVertex_back_svertex_set, + (char *)TVertex_back_svertex_doc, + NULL}, + {(char *)"id", (getter)TVertex_id_get, (setter)TVertex_id_set, (char *)TVertex_id_doc, NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; /*-----------------------BPy_TVertex type definition ------------------------------*/ PyTypeObject TVertex_Type = { - PyVarObject_HEAD_INIT(NULL, 0) - "TVertex", /* tp_name */ - sizeof(BPy_TVertex), /* tp_basicsize */ - 0, /* tp_itemsize */ - 0, /* tp_dealloc */ - 0, /* tp_print */ - 0, /* tp_getattr */ - 0, /* tp_setattr */ - 0, /* tp_reserved */ - 0, /* tp_repr */ - 0, /* tp_as_number */ - 0, /* tp_as_sequence */ - 0, /* tp_as_mapping */ - 0, /* tp_hash */ - 0, /* tp_call */ - 0, /* tp_str */ - 0, /* tp_getattro */ - 0, /* tp_setattro */ - 0, /* tp_as_buffer */ - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ - TVertex_doc, /* tp_doc */ - 0, /* tp_traverse */ - 0, /* tp_clear */ - 0, /* tp_richcompare */ - 0, /* tp_weaklistoffset */ - 0, /* tp_iter */ - 0, /* tp_iternext */ - BPy_TVertex_methods, /* tp_methods */ - 0, /* tp_members */ - BPy_TVertex_getseters, /* tp_getset */ - &ViewVertex_Type, /* tp_base */ - 0, /* tp_dict */ - 0, /* tp_descr_get */ - 0, /* tp_descr_set */ - 0, /* tp_dictoffset */ - (initproc)TVertex_init, /* tp_init */ - 0, /* tp_alloc */ - 0, /* tp_new */ + PyVarObject_HEAD_INIT(NULL, 0) "TVertex", /* tp_name */ + sizeof(BPy_TVertex), /* tp_basicsize */ + 0, /* tp_itemsize */ + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_reserved */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + TVertex_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + BPy_TVertex_methods, /* tp_methods */ + 0, /* tp_members */ + BPy_TVertex_getseters, /* tp_getset */ + &ViewVertex_Type, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)TVertex_init, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ }; /////////////////////////////////////////////////////////////////////////////////////////// diff --git a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.h b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.h index a7526ffd1c4..165ad976fdf 100644 --- a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.h +++ b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.h @@ -37,8 +37,8 @@ extern PyTypeObject TVertex_Type; /*---------------------------Python BPy_TVertex structure definition----------*/ typedef struct { - BPy_ViewVertex py_vv; - TVertex *tv; + BPy_ViewVertex py_vv; + TVertex *tv; } BPy_TVertex; /////////////////////////////////////////////////////////////////////////////////////////// -- cgit v1.2.3