archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Freestyle Python API improvements - part 3.

Browse Source 
Major API updates were made to address code review comments.
This revision mostly focuses on Python wrappers of C++ 0D and 1D elements (i.e.,
Interface0D and Interface1D, as well as their subclasses).

* Most getter/setter methods were reimplemented as attributes using PyGetSetDef.
Vector attributes are now implemented based on mathutils callbacks.  Boolean
attributes now only accept boolean values.

* The __getitem__ method was removed and the Sequence protocol was used instead.

* The naming of methods and attributes was fixed to follow the naming conventions
of the Blender Python API (i.e., lower case + underscores for methods and attributes,
and CamelCase for classes).  Some naming inconsistency within the Freestyle Python
API was also addressed.

* The Freestyle API had a number of method names including prefix/suffix "A" and
"B", and their meanings were inconsistent (i.e., referring to different things
depending on the classes).  The names with these two letters were replaced with
more straightforward names.  Also some attribute names were changed so as to indicate
the type of the value (e.g., FEdge.next_fedge instead of FEdge.next_edge) in line
with other names explicitly indicating what the value is (e.g., SVertex.viewvertex).

* In addition, some code clean-up was done in both C++ and Python.

Notes:

In summary, the following irregular naming changes were made through this revision
(those resulting from regular changes of naming conventions are not listed):

- CurvePoint: {A,B} --> {first,second}_svertex
- FEdge: vertex{A,B} --> {first,second}_svertex
- FEdge: {next,previous}Edge --> {next,previous}_fedge
- FEdgeSharp: normal{A,B} --> normal_{right,left}
- FEdgeSharp: {a,b}FaceMark --> face_mark_{right,left}
- FEdgeSharp: {a,b}Material --> material_{right,left}
- FEdgeSharp: {a,b}MaterialIndex --> material_index_{right,left}
- FrsCurve: empty --> is_empty
- FrsCurve: nSegments --> segments_size
- TVertex: mate() --> get_mate()
- ViewEdge: fedge{A,B} --> {first,last}_fedge
- ViewEdge: setaShape, aShape --> occlude
- ViewEdge: {A,B} --> {first,last}_viewvertex
- ViewMap: getScene3dBBox --> scene_bbox
This commit is contained in:
Tamito Kajiyama
2013-02-14 23:48:34 +00:00
parent 9e3bf44011
commit 731d08d497
27 changed files with 3149 additions and 3551 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.cpp
View File

@@ -9,9 +9,9 @@ extern "C" {
///////////////////////////////////////////////////////////////////////////////////////////
//------------------------INSTANCE METHODS ----------------------------------
/*----------------------NonTVertex methods ----------------------------*/
static char NonTVertex___doc__[] =
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"
@@ -33,21 +33,20 @@ static char NonTVertex___doc__[] =
" Builds a NonTVertex from a SVertex.\n"
"\n"
" :arg iSVertex: An SVertex object.\n"
" :type iSVertex: :class:`SVertex`\n";
" :type iSVertex: :class:`SVertex`");
static int NonTVertex___init__(BPy_NonTVertex *self, PyObject *args, PyObject *kwds)
static int NonTVertex_init(BPy_NonTVertex *self, PyObject *args, PyObject *kwds)
{
PyObject *obj = 0;
if (! PyArg_ParseTuple(args, "|O!", &SVertex_Type, &obj) )
return -1;
if (!PyArg_ParseTuple(args, "|O!", &SVertex_Type, &obj))
return -1;
if( !obj ){
if (!obj) {
self->ntv = new NonTVertex();
} else if( ((BPy_SVertex *) obj)->sv ) {
self->ntv = new NonTVertex( ((BPy_SVertex *) obj)->sv );
} else if(((BPy_SVertex *)obj)->sv) {
self->ntv = new NonTVertex(((BPy_SVertex *)obj)->sv);
} else {
PyErr_SetString(PyExc_TypeError, "invalid argument");
@@ -61,49 +60,40 @@ static int NonTVertex___init__(BPy_NonTVertex *self, PyObject *args, PyObject *k
return 0;
}
static char NonTVertex_svertex___doc__[] =
".. method:: svertex()\n"
"\n"
" Returns the SVertex on top of which this NonTVertex is built.\n"
"\n"
" :return: The SVertex on top of which this NonTVertex is built.\n"
" :rtype: :class:`SVertex`\n";
static PyObject * NonTVertex_svertex( BPy_NonTVertex *self ) {
SVertex *v = self->ntv->svertex();
if( v ){
return BPy_SVertex_from_SVertex( *v );
}
Py_RETURN_NONE;
}
static char NonTVertex_setSVertex___doc__[] =
".. method:: setSVertex(iSVertex)\n"
"\n"
" Sets the SVertex on top of which this NonTVertex is built.\n"
"\n"
" :arg iSVertex: The SVertex on top of which this NonTVertex is built.\n"
" :type iSVertex: :class:`SVertex`\n";
static PyObject * NonTVertex_setSVertex( BPy_NonTVertex *self, PyObject *args) {
PyObject *py_sv;
if(!( PyArg_ParseTuple(args, "O!", &SVertex_Type, &py_sv) ))
return NULL;
self->ntv->setSVertex( ((BPy_SVertex *) py_sv)->sv );
Py_RETURN_NONE;
}
/*----------------------NonTVertex instance definitions ----------------------------*/
static PyMethodDef BPy_NonTVertex_methods[] = {
{"svertex", ( PyCFunction ) NonTVertex_svertex, METH_NOARGS, NonTVertex_svertex___doc__},
{"setSVertex", ( PyCFunction ) NonTVertex_setSVertex, METH_VARARGS, NonTVertex_setSVertex___doc__},
{NULL, NULL, 0, NULL}
};
/*----------------------NonTVertex get/setters ----------------------------*/
PyDoc_STRVAR(NonTVertex_svertex_doc,
"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;
}
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;
}
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 */
};
/*-----------------------BPy_NonTVertex type definition ------------------------------*/
PyTypeObject NonTVertex_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
@@ -126,7 +116,7 @@ PyTypeObject NonTVertex_Type = {
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
NonTVertex___doc__, /* tp_doc */
NonTVertex_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
@@ -135,13 +125,13 @@ PyTypeObject NonTVertex_Type = {
0, /* tp_iternext */
BPy_NonTVertex_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
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 */
(initproc)NonTVertex_init, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
};

239
source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp
View File

@@ -12,9 +12,9 @@ extern "C" {
///////////////////////////////////////////////////////////////////////////////////////////
//------------------------INSTANCE METHODS ----------------------------------
/*----------------------TVertex methods ----------------------------*/
static char TVertex___doc__[] =
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"
@@ -32,138 +32,43 @@ static char TVertex___doc__[] =
" Copy constructor.\n"
"\n"
" :arg iBrother: A TVertex object.\n"
" :type iBrother: :class:`TVertex`\n";
" :type iBrother: :class:`TVertex`");
static int TVertex___init__(BPy_TVertex *self, PyObject *args, PyObject *kwds)
static int TVertex_init(BPy_TVertex *self, PyObject *args, PyObject *kwds)
{
if( !PyArg_ParseTuple(args, "") )
return -1;
if (!PyArg_ParseTuple(args, ""))
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 = 0;
return 0;
}
static char TVertex_frontSVertex___doc__[] =
".. method:: frontSVertex()\n"
"\n"
" Returns the SVertex that is closer to the viewpoint.\n"
"\n"
" :return: The SVertex that is closer to the viewpoint.\n"
" :rtype: :class:`SVertex`\n";
static PyObject * TVertex_frontSVertex( BPy_TVertex *self ) {
SVertex *v = self->tv->frontSVertex();
if( v ){
return BPy_SVertex_from_SVertex( *v );
}
Py_RETURN_NONE;
}
static char TVertex_backSVertex___doc__[] =
".. method:: backSVertex()\n"
"\n"
" Returns the SVertex that is further away from the viewpoint.\n"
"\n"
" :return: The SVertex that is further away from the viewpoint.\n"
" :rtype: :class:`SVertex`\n";
static PyObject * TVertex_backSVertex( BPy_TVertex *self ) {
SVertex *v = self->tv->backSVertex();
if( v ){
return BPy_SVertex_from_SVertex( *v );
}
Py_RETURN_NONE;
}
static char TVertex_setFrontSVertex___doc__[] =
".. method:: setFrontSVertex(iFrontSVertex)\n"
"\n"
" Sets the SVertex that is closer to the viewpoint.\n"
"\n"
" :arg iFrontSVertex: An SVertex object.\n"
" :type iFrontSVertex: :class:`SVertex`\n";
static PyObject * TVertex_setFrontSVertex( BPy_TVertex *self, PyObject *args) {
PyObject *py_sv;
if(!( PyArg_ParseTuple(args, "O!", &SVertex_Type, &py_sv) ))
return NULL;
self->tv->setFrontSVertex( ((BPy_SVertex *) py_sv)->sv );
Py_RETURN_NONE;
}
static char TVertex_setBackSVertex___doc__[] =
".. method:: setBackSVertex(iBackSVertex)\n"
"\n"
" Sets the SVertex that is further away from the viewpoint.\n"
"\n"
" :arg iBackSVertex: An SVertex object.\n"
" :type iBackSVertex: :class:`SVertex`\n";
static PyObject * TVertex_setBackSVertex( BPy_TVertex *self, PyObject *args) {
PyObject *py_sv;
if(!( PyArg_ParseTuple(args, "O", &SVertex_Type, &py_sv) ))
return NULL;
self->tv->setBackSVertex( ((BPy_SVertex *) py_sv)->sv );
Py_RETURN_NONE;
}
static char TVertex_setId___doc__[] =
".. method:: setId(iId)\n"
"\n"
" Sets the Id.\n"
"\n"
" :arg iId: An Id object.\n"
" :type iId: :class:`Id`\n";
static PyObject * TVertex_setId( BPy_TVertex *self, PyObject *args) {
PyObject *py_id;
if(!( PyArg_ParseTuple(args, "O!", &Id_Type, &py_id) ))
return NULL;
if( ((BPy_Id *) py_id)->id )
self->tv->setId(*( ((BPy_Id *) py_id)->id ));
Py_RETURN_NONE;
}
static char TVertex_getSVertex___doc__[] =
".. method:: getSVertex(iFEdge)\n"
PyDoc_STRVAR(TVertex_get_svertex_doc,
".. method:: get_svertex(iFEdge)\n"
"\n"
" Returns the SVertex (among the 2) belonging to the given FEdge.\n"
"\n"
" :arg iFEdge: An FEdge object.\n"
" :type iFEdge: :class:`FEdge`\n"
" :return: The SVertex belonging to the given FEdge.\n"
" :rtype: :class:`SVertex`\n";
" :rtype: :class:`SVertex`");
static PyObject * TVertex_getSVertex( BPy_TVertex *self, PyObject *args) {
static PyObject * TVertex_get_svertex( BPy_TVertex *self, PyObject *args)
{
PyObject *py_fe;
if(!( PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe) ))
if (!PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe))
return NULL;
SVertex *sv = self->tv->getSVertex( ((BPy_FEdge *) py_fe)->fe );
if( sv ){
return BPy_SVertex_from_SVertex( *sv );
}
SVertex *sv = self->tv->getSVertex(((BPy_FEdge *)py_fe)->fe);
if (sv)
return BPy_SVertex_from_SVertex(*sv);
Py_RETURN_NONE;
}
static char TVertex_mate___doc__[] =
".. method:: mate(iEdgeA)\n"
PyDoc_STRVAR(TVertex_get_mate_doc,
".. method:: get_mate(iEdgeA)\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"
@@ -172,34 +77,102 @@ static char TVertex_mate___doc__[] =
" :arg iEdgeA: A ViewEdge object.\n"
" :type iEdgeA: :class:`ViewEdge`\n"
" :return: The mate edge of the given ViewEdge.\n"
" :rtype: :class:`ViewEdge`\n";
" :rtype: :class:`ViewEdge`");
static PyObject * TVertex_mate( BPy_TVertex *self, PyObject *args) {
static PyObject * TVertex_get_mate( BPy_TVertex *self, PyObject *args)
{
PyObject *py_ve;
if(!( PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve) ))
if (!PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve))
return NULL;
ViewEdge *ve = self->tv->mate( ((BPy_ViewEdge *) py_ve)->ve );
if( ve ){
return BPy_ViewEdge_from_ViewEdge( *ve );
}
ViewEdge *ve = self->tv->mate(((BPy_ViewEdge *)py_ve)->ve);
if (ve)
return BPy_ViewEdge_from_ViewEdge(*ve);
Py_RETURN_NONE;
}
/*----------------------TVertex instance definitions ----------------------------*/
static PyMethodDef BPy_TVertex_methods[] = {
{"frontSVertex", ( PyCFunction ) TVertex_frontSVertex, METH_NOARGS, TVertex_frontSVertex___doc__},
{"backSVertex", ( PyCFunction ) TVertex_backSVertex, METH_NOARGS, TVertex_backSVertex___doc__},
{"setFrontSVertex", ( PyCFunction ) TVertex_setFrontSVertex, METH_VARARGS, TVertex_setFrontSVertex___doc__},
{"setBackSVertex", ( PyCFunction ) TVertex_setBackSVertex, METH_VARARGS, TVertex_setBackSVertex___doc__},
{"setId", ( PyCFunction ) TVertex_setId, METH_VARARGS, TVertex_setId___doc__},
{"getSVertex", ( PyCFunction ) TVertex_getSVertex, METH_VARARGS, TVertex_getSVertex___doc__},
{"mate", ( PyCFunction ) TVertex_mate, METH_VARARGS, TVertex_mate___doc__},
static PyMethodDef BPy_TVertex_methods[] = {
{"get_svertex", (PyCFunction)TVertex_get_svertex, METH_VARARGS, TVertex_get_svertex_doc},
{"get_mate", (PyCFunction)TVertex_get_mate, METH_VARARGS, 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`");
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;
}
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;
}
PyDoc_STRVAR(TVertex_back_svertex_doc,
"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;
}
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;
}
PyDoc_STRVAR(TVertex_id_doc,
"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
}
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;
}
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 */
};
/*-----------------------BPy_TVertex type definition ------------------------------*/
PyTypeObject TVertex_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
@@ -222,7 +195,7 @@ PyTypeObject TVertex_Type = {
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
TVertex___doc__, /* tp_doc */
TVertex_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
@@ -231,13 +204,13 @@ PyTypeObject TVertex_Type = {
0, /* tp_iternext */
BPy_TVertex_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
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 */
(initproc)TVertex_init, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
};