From 21674d2db2dbc932fa87699768c1ebb2f61bc941 Mon Sep 17 00:00:00 2001 From: Maxime Curioni Date: Fri, 18 Jul 2008 04:59:07 +0000 Subject: soc-2008-mxcurioni: canvas for UnaryFunction0D, UnaryFunction1D, UnaryPredicate0D, UnaryPredicate1D. UnaryFunction0D and UnaryFunction1D implementations are going to be really challenging due to the changes in the infrastructure: UnaryFunction0D and UnaryFunction0D are templates and must be determined for compile-time. The easiest solution is to support each type individually; unfortunately, it removes the benefit of using an interface. To find a middle ground, a general unary function Python object type was created for 0D and 1D. In both cases, the types have a void* pointer keeping the address of the current unary function type. I am not sure yet if it will work. Interface0DIterator being removed by a list type, the t() and u() coordinate functions will to be transferred somehow, probably directly at the Interface0D level. --- .../blender/freestyle/intern/python/Freestyle.cpp | 9 +- .../freestyle/intern/python/UnaryFunction0D.cpp | 173 ++++++++++++++++++++ .../freestyle/intern/python/UnaryFunction0D.h | 35 +++++ .../intern/python/UnaryFunction0DVoid.cpp | 12 -- .../freestyle/intern/python/UnaryFunction1D.cpp | 175 +++++++++++++++++++++ .../freestyle/intern/python/UnaryFunction1D.h | 35 +++++ .../intern/python/UnaryFunction1DVoid.cpp | 20 --- .../freestyle/intern/python/UnaryPredicate0D.cpp | 164 ++++++++++++++++++- .../freestyle/intern/python/UnaryPredicate0D.h | 35 +++++ .../freestyle/intern/python/UnaryPredicate1D.cpp | 164 ++++++++++++++++++- .../freestyle/intern/python/UnaryPredicate1D.h | 35 +++++ 11 files changed, 818 insertions(+), 39 deletions(-) create mode 100644 source/blender/freestyle/intern/python/UnaryFunction0D.cpp create mode 100644 source/blender/freestyle/intern/python/UnaryFunction0D.h delete mode 100644 source/blender/freestyle/intern/python/UnaryFunction0DVoid.cpp create mode 100644 source/blender/freestyle/intern/python/UnaryFunction1D.cpp create mode 100644 source/blender/freestyle/intern/python/UnaryFunction1D.h delete mode 100644 source/blender/freestyle/intern/python/UnaryFunction1DVoid.cpp create mode 100644 source/blender/freestyle/intern/python/UnaryPredicate0D.h create mode 100644 source/blender/freestyle/intern/python/UnaryPredicate1D.h (limited to 'source/blender/freestyle/intern/python') diff --git a/source/blender/freestyle/intern/python/Freestyle.cpp b/source/blender/freestyle/intern/python/Freestyle.cpp index 9630aa38f80..809568abe2c 100644 --- a/source/blender/freestyle/intern/python/Freestyle.cpp +++ b/source/blender/freestyle/intern/python/Freestyle.cpp @@ -6,7 +6,10 @@ #include "Interface0D.h" #include "Interface0D/CurvePoint.h" #include "Interface1D.h" - +#include "UnaryFunction0D.h" +#include "UnaryFunction1D.h" +#include "UnaryPredicate0D.h" +#include "UnaryPredicate1D.h" #ifdef __cplusplus extern "C" { @@ -127,6 +130,10 @@ PyObject *Freestyle_Init( void ) Id_Init( module ); Interface0D_Init( module ); Interface1D_Init( module ); + UnaryFunction0D_Init( module ); + UnaryFunction1D_Init( module ); + UnaryPredicate0D_Init( module ); + UnaryPredicate1D_Init( module ); return module; } diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D.cpp b/source/blender/freestyle/intern/python/UnaryFunction0D.cpp new file mode 100644 index 00000000000..b9da3dfc20d --- /dev/null +++ b/source/blender/freestyle/intern/python/UnaryFunction0D.cpp @@ -0,0 +1,173 @@ +#include "UnaryFunction0D.h" + +#include "Convert.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/////////////////////////////////////////////////////////////////////////////////////////// + +/*--------------- Python API function prototypes for UnaryFunction0D instance -----------*/ +static int UnaryFunction0D___init__(BPy_UnaryFunction0D *self, PyObject *args, PyObject *kwds); +static void UnaryFunction0D___dealloc__(BPy_UnaryFunction0D *self); +static PyObject * UnaryFunction0D___repr__(BPy_UnaryFunction0D *self); + +static PyObject * UnaryFunction0D_getName( BPy_UnaryFunction0D *self, PyObject *args); +static PyObject * UnaryFunction0D___call__( BPy_UnaryFunction0D *self, PyObject *args); + +/*----------------------UnaryFunction0D instance definitions ----------------------------*/ +static PyMethodDef BPy_UnaryFunction0D_methods[] = { + {"getName", ( PyCFunction ) UnaryFunction0D_getName, METH_NOARGS, ""}, + {"__call__", ( PyCFunction ) UnaryFunction0D___call__, METH_VARARGS, "" }, + {NULL, NULL, 0, NULL} +}; + +/*-----------------------BPy_UnaryFunction0D type definition ------------------------------*/ + +PyTypeObject UnaryFunction0D_Type = { + PyObject_HEAD_INIT( NULL ) + 0, /* ob_size */ + "UnaryFunction0D", /* tp_name */ + sizeof( BPy_UnaryFunction0D ), /* tp_basicsize */ + 0, /* tp_itemsize */ + + /* methods */ + (destructor)UnaryFunction0D___dealloc__, /* tp_dealloc */ + NULL, /* printfunc tp_print; */ + NULL, /* getattrfunc tp_getattr; */ + NULL, /* setattrfunc tp_setattr; */ + NULL, /* tp_compare */ + (reprfunc)UnaryFunction0D___repr__, /* tp_repr */ + + /* Method suites for standard classes */ + + NULL, /* PyNumberMethods *tp_as_number; */ + NULL, /* PySequenceMethods *tp_as_sequence; */ + NULL, /* PyMappingMethods *tp_as_mapping; */ + + /* More standard operations (here for binary compatibility) */ + + NULL, /* hashfunc tp_hash; */ + NULL, /* ternaryfunc tp_call; */ + NULL, /* reprfunc tp_str; */ + NULL, /* getattrofunc tp_getattro; */ + NULL, /* setattrofunc tp_setattro; */ + + /* Functions to access object as input/output buffer */ + NULL, /* PyBufferProcs *tp_as_buffer; */ + + /*** Flags to define presence of optional/expanded features ***/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */ + + NULL, /* char *tp_doc; Documentation string */ + /*** Assigned meaning in release 2.0 ***/ + /* call function for all accessible objects */ + NULL, /* traverseproc tp_traverse; */ + + /* delete references to contained objects */ + NULL, /* inquiry tp_clear; */ + + /*** Assigned meaning in release 2.1 ***/ + /*** rich comparisons ***/ + NULL, /* richcmpfunc tp_richcompare; */ + + /*** weak reference enabler ***/ + 0, /* long tp_weaklistoffset; */ + + /*** Added in release 2.2 ***/ + /* Iterators */ + NULL, /* getiterfunc tp_iter; */ + NULL, /* iternextfunc tp_iternext; */ + + /*** Attribute descriptor and subclassing stuff ***/ + BPy_UnaryFunction0D_methods, /* struct PyMethodDef *tp_methods; */ + NULL, /* struct PyMemberDef *tp_members; */ + NULL, /* struct PyGetSetDef *tp_getset; */ + NULL, /* struct _typeobject *tp_base; */ + NULL, /* PyObject *tp_dict; */ + NULL, /* descrgetfunc tp_descr_get; */ + NULL, /* descrsetfunc tp_descr_set; */ + 0, /* long tp_dictoffset; */ + (initproc)UnaryFunction0D___init__, /* initproc tp_init; */ + NULL, /* allocfunc tp_alloc; */ + PyType_GenericNew, /* newfunc tp_new; */ + + /* Low-level free-memory routine */ + NULL, /* freefunc tp_free; */ + + /* For PyObject_IS_GC */ + NULL, /* inquiry tp_is_gc; */ + NULL, /* PyObject *tp_bases; */ + + /* method resolution order */ + NULL, /* PyObject *tp_mro; */ + NULL, /* PyObject *tp_cache; */ + NULL, /* PyObject *tp_subclasses; */ + NULL, /* PyObject *tp_weaklist; */ + NULL +}; + +//-------------------MODULE INITIALIZATION-------------------------------- +PyMODINIT_FUNC UnaryFunction0D_Init( PyObject *module ) +{ + if( module == NULL ) + return; + + if( PyType_Ready( &UnaryFunction0D_Type ) < 0 ) + return; + Py_INCREF( &UnaryFunction0D_Type ); + PyModule_AddObject(module, "UnaryFunction0D", (PyObject *)&UnaryFunction0D_Type); +} + +//------------------------INSTANCE METHODS ---------------------------------- + +int UnaryFunction0D___init__(BPy_UnaryFunction0D *self, PyObject *args, PyObject *kwds) +{ + return 0; +} + +void UnaryFunction0D___dealloc__(BPy_UnaryFunction0D* self) +{ + //delete self->uf0D; + self->ob_type->tp_free((PyObject*)self); +} + + +PyObject * UnaryFunction0D___repr__(BPy_UnaryFunction0D* self) +{ + return PyString_FromFormat("type: %s - address: %p", ((UnaryFunction0D *) self->uf0D)->getName().c_str(), self->uf0D ); +} + + +PyObject * UnaryFunction0D_getName( BPy_UnaryFunction0D *self, PyObject *args) +{ + return PyString_FromString( ((UnaryFunction0D *) self->uf0D)->getName().c_str() ); +} + +PyObject * UnaryFunction0D___call__( BPy_UnaryFunction0D *self, PyObject *args) +{ + PyObject *l; + + if( !PyArg_ParseTuple(args, "O", &l) ) { + cout << "ERROR: UnaryFunction0D___call__ " << endl; + return NULL; + } + + // pb: operator() is called on Interface0DIterator while we have a list + // solutions: + // 1)reconvert back to iterator ? + // 2) adapt interface0d to have t(), u() functions + + // b = self->bp0D->operator()( *(obj1->uf0D) ); + // return PyBool_from_bool( b ); + + Py_RETURN_NONE; +} + + +/////////////////////////////////////////////////////////////////////////////////////////// + +#ifdef __cplusplus +} +#endif diff --git a/source/blender/freestyle/intern/python/UnaryFunction0D.h b/source/blender/freestyle/intern/python/UnaryFunction0D.h new file mode 100644 index 00000000000..365b340d96c --- /dev/null +++ b/source/blender/freestyle/intern/python/UnaryFunction0D.h @@ -0,0 +1,35 @@ +#ifndef FREESTYLE_PYTHON_UNARYFUNCTION0D_H +#define FREESTYLE_PYTHON_UNARYFUNCTION0D_H + +#include "../view_map/Functions0D.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/////////////////////////////////////////////////////////////////////////////////////////// + +#include + +extern PyTypeObject UnaryFunction0D_Type; + +#define BPy_UnaryFunction0D_Check(v) \ + ((v)->ob_type == &UnaryFunction0D_Type) + +/*---------------------------Python BPy_UnaryFunction0D structure definition----------*/ +typedef struct { + PyObject_HEAD + void *uf0D; +} BPy_UnaryFunction0D; + +/*---------------------------Python BPy_UnaryFunction0D visible prototypes-----------*/ + +PyMODINIT_FUNC UnaryFunction0D_Init( PyObject *module ); + +/////////////////////////////////////////////////////////////////////////////////////////// + +#ifdef __cplusplus +} +#endif + +#endif /* FREESTYLE_PYTHON_UNARYFUNCTION0D_H */ diff --git a/source/blender/freestyle/intern/python/UnaryFunction0DVoid.cpp b/source/blender/freestyle/intern/python/UnaryFunction0DVoid.cpp deleted file mode 100644 index 92a87b04a80..00000000000 --- a/source/blender/freestyle/intern/python/UnaryFunction0DVoid.cpp +++ /dev/null @@ -1,12 +0,0 @@ - PyObject *_wrap_UnaryFunction0DVoid_getName(PyObject *self , PyObject *args) { -} - - - PyObject *_wrap_UnaryFunction0DVoid___call__(PyObject *self , PyObject *args) { -} - - - PyObject *_wrap_disown_UnaryFunction0DVoid(PyObject *self , PyObject *args) { -} - - diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D.cpp b/source/blender/freestyle/intern/python/UnaryFunction1D.cpp new file mode 100644 index 00000000000..db026ced338 --- /dev/null +++ b/source/blender/freestyle/intern/python/UnaryFunction1D.cpp @@ -0,0 +1,175 @@ +#include "UnaryFunction1D.h" + +#include "Convert.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/////////////////////////////////////////////////////////////////////////////////////////// + +/*--------------- Python API function prototypes for UnaryFunction1D instance -----------*/ +static int UnaryFunction1D___init__(BPy_UnaryFunction1D *self, PyObject *args, PyObject *kwds); +static void UnaryFunction1D___dealloc__(BPy_UnaryFunction1D *self); +static PyObject * UnaryFunction1D___repr__(BPy_UnaryFunction1D *self); + +static PyObject * UnaryFunction1D_getName( BPy_UnaryFunction1D *self, PyObject *args); +static PyObject * UnaryFunction1D___call__( BPy_UnaryFunction1D *self, PyObject *args); + +/*----------------------UnaryFunction1D instance definitions ----------------------------*/ +static PyMethodDef BPy_UnaryFunction1D_methods[] = { + {"getName", ( PyCFunction ) UnaryFunction1D_getName, METH_NOARGS, ""}, + {"__call__", ( PyCFunction ) UnaryFunction1D___call__, METH_VARARGS, "" }, + {NULL, NULL, 0, NULL} +}; + +/*-----------------------BPy_UnaryFunction1D type definition ------------------------------*/ + +PyTypeObject UnaryFunction1D_Type = { + PyObject_HEAD_INIT( NULL ) + 0, /* ob_size */ + "UnaryFunction1D", /* tp_name */ + sizeof( BPy_UnaryFunction1D ), /* tp_basicsize */ + 0, /* tp_itemsize */ + + /* methods */ + (destructor)UnaryFunction1D___dealloc__, /* tp_dealloc */ + NULL, /* printfunc tp_print; */ + NULL, /* getattrfunc tp_getattr; */ + NULL, /* setattrfunc tp_setattr; */ + NULL, /* tp_compare */ + (reprfunc)UnaryFunction1D___repr__, /* tp_repr */ + + /* Method suites for standard classes */ + + NULL, /* PyNumberMethods *tp_as_number; */ + NULL, /* PySequenceMethods *tp_as_sequence; */ + NULL, /* PyMappingMethods *tp_as_mapping; */ + + /* More standard operations (here for binary compatibility) */ + + NULL, /* hashfunc tp_hash; */ + NULL, /* ternaryfunc tp_call; */ + NULL, /* reprfunc tp_str; */ + NULL, /* getattrofunc tp_getattro; */ + NULL, /* setattrofunc tp_setattro; */ + + /* Functions to access object as input/output buffer */ + NULL, /* PyBufferProcs *tp_as_buffer; */ + + /*** Flags to define presence of optional/expanded features ***/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */ + + NULL, /* char *tp_doc; Documentation string */ + /*** Assigned meaning in release 2.0 ***/ + /* call function for all accessible objects */ + NULL, /* traverseproc tp_traverse; */ + + /* delete references to contained objects */ + NULL, /* inquiry tp_clear; */ + + /*** Assigned meaning in release 2.1 ***/ + /*** rich comparisons ***/ + NULL, /* richcmpfunc tp_richcompare; */ + + /*** weak reference enabler ***/ + NULL, /* long tp_weaklistoffset; */ + + /*** Added in release 2.2 ***/ + /* Iterators */ + NULL, /* getiterfunc tp_iter; */ + NULL, /* iternextfunc tp_iternext; */ + + /*** Attribute descriptor and subclassing stuff ***/ + BPy_UnaryFunction1D_methods, /* struct PyMethodDef *tp_methods; */ + NULL, /* struct PyMemberDef *tp_members; */ + NULL, /* struct PyGetSetDef *tp_getset; */ + NULL, /* struct _typeobject *tp_base; */ + NULL, /* PyObject *tp_dict; */ + NULL, /* descrgetfunc tp_descr_get; */ + NULL, /* descrsetfunc tp_descr_set; */ + NULL, /* long tp_dictoffset; */ + (initproc)UnaryFunction1D___init__, /* initproc tp_init; */ + NULL, /* allocfunc tp_alloc; */ + PyType_GenericNew, /* newfunc tp_new; */ + + /* Low-level free-memory routine */ + NULL, /* freefunc tp_free; */ + + /* For PyObject_IS_GC */ + NULL, /* inquiry tp_is_gc; */ + NULL, /* PyObject *tp_bases; */ + + /* method resolution order */ + NULL, /* PyObject *tp_mro; */ + NULL, /* PyObject *tp_cache; */ + NULL, /* PyObject *tp_subclasses; */ + NULL, /* PyObject *tp_weaklist; */ + NULL +}; + +//-------------------MODULE INITIALIZATION-------------------------------- +PyMODINIT_FUNC UnaryFunction1D_Init( PyObject *module ) +{ + if( module == NULL ) + return; + + if( PyType_Ready( &UnaryFunction1D_Type ) < 0 ) + return; + Py_INCREF( &UnaryFunction1D_Type ); + PyModule_AddObject(module, "UnaryFunction1D", (PyObject *)&UnaryFunction1D_Type); +} + +//------------------------INSTANCE METHODS ---------------------------------- + +int UnaryFunction1D___init__(BPy_UnaryFunction1D *self, PyObject *args, PyObject *kwds) +{ + return 0; +} + +void UnaryFunction1D___dealloc__(BPy_UnaryFunction1D* self) +{ + //delete self->uf1D; + self->ob_type->tp_free((PyObject*)self); +} + + +PyObject * UnaryFunction1D___repr__(BPy_UnaryFunction1D* self) +{ + return PyString_FromFormat("type: %s - address: %p", ((UnaryFunction1D *) self->uf1D)->getName().c_str(), self->uf1D ); +} + + +PyObject * UnaryFunction1D_getName( BPy_UnaryFunction1D *self, PyObject *args) +{ + return PyString_FromString( ((UnaryFunction1D *) self->uf1D)->getName().c_str() ); +} + +PyObject * UnaryFunction1D___call__( BPy_UnaryFunction1D *self, PyObject *args) +{ + PyObject *l; + + if( !PyArg_ParseTuple(args, "O", &l) ) { + cout << "ERROR: UnaryFunction1D___call__ " << endl; + return NULL; + } + + // pb: operator() is called on Interface0DIterator while we have a list + // solutions: + // 1)reconvert back to iterator ? + // 2) adapt interface0d to have t(), u() functions + + // b = self->bp0D->operator()( *(obj1->uf0D) ); + // return PyBool_from_bool( b ); + + Py_RETURN_NONE; +} + +// void setIntegrationType (IntegrationType integration) +// IntegrationType getIntegrationType () const + +/////////////////////////////////////////////////////////////////////////////////////////// + +#ifdef __cplusplus +} +#endif diff --git a/source/blender/freestyle/intern/python/UnaryFunction1D.h b/source/blender/freestyle/intern/python/UnaryFunction1D.h new file mode 100644 index 00000000000..2ad187ca81d --- /dev/null +++ b/source/blender/freestyle/intern/python/UnaryFunction1D.h @@ -0,0 +1,35 @@ +#ifndef FREESTYLE_PYTHON_UNARYFUNCTION1D_H +#define FREESTYLE_PYTHON_UNARYFUNCTION1D_H + +#include "../view_map/Functions1D.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/////////////////////////////////////////////////////////////////////////////////////////// + +#include + +extern PyTypeObject UnaryFunction1D_Type; + +#define BPy_UnaryFunction1D_Check(v) \ + ((v)->ob_type == &UnaryFunction1D_Type) + +/*---------------------------Python BPy_UnaryFunction1D structure definition----------*/ +typedef struct { + PyObject_HEAD + void *uf1D; +} BPy_UnaryFunction1D; + +/*---------------------------Python BPy_UnaryFunction1D visible prototypes-----------*/ + +PyMODINIT_FUNC UnaryFunction1D_Init( PyObject *module ); + +/////////////////////////////////////////////////////////////////////////////////////////// + +#ifdef __cplusplus +} +#endif + +#endif /* FREESTYLE_PYTHON_UNARYFUNCTION1D_H */ diff --git a/source/blender/freestyle/intern/python/UnaryFunction1DVoid.cpp b/source/blender/freestyle/intern/python/UnaryFunction1DVoid.cpp deleted file mode 100644 index 13c8a088dfb..00000000000 --- a/source/blender/freestyle/intern/python/UnaryFunction1DVoid.cpp +++ /dev/null @@ -1,20 +0,0 @@ - PyObject *_wrap_UnaryFunction1DVoid_getName(PyObject *self , PyObject *args) { -} - - - PyObject *_wrap_UnaryFunction1DVoid___call__(PyObject *self , PyObject *args) { -} - - - PyObject *_wrap_UnaryFunction1DVoid_setIntegrationType(PyObject *self , PyObject *args) { -} - - - PyObject *_wrap_UnaryFunction1DVoid_getIntegrationType(PyObject *self , PyObject *args) { -} - - - PyObject *_wrap_disown_UnaryFunction1DVoid(PyObject *self , PyObject *args) { -} - - diff --git a/source/blender/freestyle/intern/python/UnaryPredicate0D.cpp b/source/blender/freestyle/intern/python/UnaryPredicate0D.cpp index 7c67de86079..1d2fd6b284f 100644 --- a/source/blender/freestyle/intern/python/UnaryPredicate0D.cpp +++ b/source/blender/freestyle/intern/python/UnaryPredicate0D.cpp @@ -1,12 +1,170 @@ - PyObject *_wrap_UnaryPredicate0D_getName(PyObject *self , PyObject *args) { +#include "UnaryPredicate0D.h" + +#include "Convert.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/////////////////////////////////////////////////////////////////////////////////////////// + +/*--------------- Python API function prototypes for UnaryPredicate0D instance -----------*/ +static int UnaryPredicate0D___init__(BPy_UnaryPredicate0D *self, PyObject *args, PyObject *kwds); +static void UnaryPredicate0D___dealloc__(BPy_UnaryPredicate0D *self); +static PyObject * UnaryPredicate0D___repr__(BPy_UnaryPredicate0D *self); + +static PyObject * UnaryPredicate0D_getName( BPy_UnaryPredicate0D *self, PyObject *args); +static PyObject * UnaryPredicate0D___call__( BPy_UnaryPredicate0D *self, PyObject *args); + +/*----------------------UnaryPredicate0D instance definitions ----------------------------*/ +static PyMethodDef BPy_UnaryPredicate0D_methods[] = { + {"getName", ( PyCFunction ) UnaryPredicate0D_getName, METH_NOARGS, ""}, + {"__call__", ( PyCFunction ) UnaryPredicate0D___call__, METH_VARARGS, "" }, + {NULL, NULL, 0, NULL} +}; + +/*-----------------------BPy_UnaryPredicate0D type definition ------------------------------*/ + +PyTypeObject UnaryPredicate0D_Type = { + PyObject_HEAD_INIT( NULL ) + 0, /* ob_size */ + "UnaryPredicate0D", /* tp_name */ + sizeof( BPy_UnaryPredicate0D ), /* tp_basicsize */ + 0, /* tp_itemsize */ + + /* methods */ + (destructor)UnaryPredicate0D___dealloc__, /* tp_dealloc */ + NULL, /* printfunc tp_print; */ + NULL, /* getattrfunc tp_getattr; */ + NULL, /* setattrfunc tp_setattr; */ + NULL, /* tp_compare */ + (reprfunc)UnaryPredicate0D___repr__, /* tp_repr */ + + /* Method suites for standard classes */ + + NULL, /* PyNumberMethods *tp_as_number; */ + NULL, /* PySequenceMethods *tp_as_sequence; */ + NULL, /* PyMappingMethods *tp_as_mapping; */ + + /* More standard operations (here for binary compatibility) */ + + NULL, /* hashfunc tp_hash; */ + NULL, /* ternaryfunc tp_call; */ + NULL, /* reprfunc tp_str; */ + NULL, /* getattrofunc tp_getattro; */ + NULL, /* setattrofunc tp_setattro; */ + + /* Functions to access object as input/output buffer */ + NULL, /* PyBufferProcs *tp_as_buffer; */ + + /*** Flags to define presence of optional/expanded features ***/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */ + + NULL, /* char *tp_doc; Documentation string */ + /*** Assigned meaning in release 2.0 ***/ + /* call function for all accessible objects */ + NULL, /* traverseproc tp_traverse; */ + + /* delete references to contained objects */ + NULL, /* inquiry tp_clear; */ + + /*** Assigned meaning in release 2.1 ***/ + /*** rich comparisons ***/ + NULL, /* richcmpfunc tp_richcompare; */ + + /*** weak reference enabler ***/ + 0, /* long tp_weaklistoffset; */ + + /*** Added in release 2.2 ***/ + /* Iterators */ + NULL, /* getiterfunc tp_iter; */ + NULL, /* iternextfunc tp_iternext; */ + + /*** Attribute descriptor and subclassing stuff ***/ + BPy_UnaryPredicate0D_methods, /* struct PyMethodDef *tp_methods; */ + NULL, /* struct PyMemberDef *tp_members; */ + NULL, /* struct PyGetSetDef *tp_getset; */ + NULL, /* struct _typeobject *tp_base; */ + NULL, /* PyObject *tp_dict; */ + NULL, /* descrgetfunc tp_descr_get; */ + NULL, /* descrsetfunc tp_descr_set; */ + 0, /* long tp_dictoffset; */ + (initproc)UnaryPredicate0D___init__, /* initproc tp_init; */ + NULL, /* allocfunc tp_alloc; */ + PyType_GenericNew, /* newfunc tp_new; */ + + /* Low-level free-memory routine */ + NULL, /* freefunc tp_free; */ + + /* For PyObject_IS_GC */ + NULL, /* inquiry tp_is_gc; */ + NULL, /* PyObject *tp_bases; */ + + /* method resolution order */ + NULL, /* PyObject *tp_mro; */ + NULL, /* PyObject *tp_cache; */ + NULL, /* PyObject *tp_subclasses; */ + NULL, /* PyObject *tp_weaklist; */ + NULL +}; + +//-------------------MODULE INITIALIZATION-------------------------------- +PyMODINIT_FUNC UnaryPredicate0D_Init( PyObject *module ) +{ + if( module == NULL ) + return; + + if( PyType_Ready( &UnaryPredicate0D_Type ) < 0 ) + return; + Py_INCREF( &UnaryPredicate0D_Type ); + PyModule_AddObject(module, "UnaryPredicate0D", (PyObject *)&UnaryPredicate0D_Type); +} + +//------------------------INSTANCE METHODS ---------------------------------- + +int UnaryPredicate0D___init__(BPy_UnaryPredicate0D *self, PyObject *args, PyObject *kwds) +{ + return 0; +} + +void UnaryPredicate0D___dealloc__(BPy_UnaryPredicate0D* self) +{ + delete self->up0D; + self->ob_type->tp_free((PyObject*)self); } - PyObject *_wrap_UnaryPredicate0D___call__(PyObject *self , PyObject *args) { +PyObject * UnaryPredicate0D___repr__(BPy_UnaryPredicate0D* self) +{ + return PyString_FromFormat("type: %s - address: %p", self->up0D->getName().c_str(), self->up0D ); } - PyObject *_wrap_disown_UnaryPredicate0D(PyObject *self , PyObject *args) { +PyObject * UnaryPredicate0D_getName( BPy_UnaryPredicate0D *self, PyObject *args) +{ + return PyString_FromString( self->up0D->getName().c_str() ); } +PyObject * UnaryPredicate0D___call__( BPy_UnaryPredicate0D *self, PyObject *args) +{ + PyObject *l; + + if( !PyArg_ParseTuple(args, "O", &l) ) { + cout << "ERROR: UnaryPredicate0D___call__ " << endl; + return NULL; + } + + //TBD + + Py_RETURN_NONE; +} + + +/////////////////////////////////////////////////////////////////////////////////////////// + +#ifdef __cplusplus +} +#endif + + diff --git a/source/blender/freestyle/intern/python/UnaryPredicate0D.h b/source/blender/freestyle/intern/python/UnaryPredicate0D.h new file mode 100644 index 00000000000..c8b9008380a --- /dev/null +++ b/source/blender/freestyle/intern/python/UnaryPredicate0D.h @@ -0,0 +1,35 @@ +#ifndef FREESTYLE_PYTHON_UNARYPREDICATE0D_H +#define FREESTYLE_PYTHON_UNARYPREDICATE0D_H + +#include "../stroke/Predicates0D.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/////////////////////////////////////////////////////////////////////////////////////////// + +#include + +extern PyTypeObject UnaryPredicate0D_Type; + +#define BPy_UnaryPredicate0D_Check(v) \ + ((v)->ob_type == &UnaryPredicate0D_Type) + +/*---------------------------Python BPy_UnaryPredicate0D structure definition----------*/ +typedef struct { + PyObject_HEAD + UnaryPredicate0D *up0D; +} BPy_UnaryPredicate0D; + +/*---------------------------Python BPy_UnaryPredicate0D visible prototypes-----------*/ + +PyMODINIT_FUNC UnaryPredicate0D_Init( PyObject *module ); + +/////////////////////////////////////////////////////////////////////////////////////////// + +#ifdef __cplusplus +} +#endif + +#endif /* FREESTYLE_PYTHON_UNARYPREDICATE0D_H */ diff --git a/source/blender/freestyle/intern/python/UnaryPredicate1D.cpp b/source/blender/freestyle/intern/python/UnaryPredicate1D.cpp index 0f2b5c4ad3a..bbbc9bfcc43 100644 --- a/source/blender/freestyle/intern/python/UnaryPredicate1D.cpp +++ b/source/blender/freestyle/intern/python/UnaryPredicate1D.cpp @@ -1,12 +1,170 @@ - PyObject *_wrap_UnaryPredicate1D_getName(PyObject *self , PyObject *args) { +#include "UnaryPredicate1D.h" + +#include "Convert.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/////////////////////////////////////////////////////////////////////////////////////////// + +/*--------------- Python API function prototypes for UnaryPredicate1D instance -----------*/ +static int UnaryPredicate1D___init__(BPy_UnaryPredicate1D *self, PyObject *args, PyObject *kwds); +static void UnaryPredicate1D___dealloc__(BPy_UnaryPredicate1D *self); +static PyObject * UnaryPredicate1D___repr__(BPy_UnaryPredicate1D *self); + +static PyObject * UnaryPredicate1D_getName( BPy_UnaryPredicate1D *self, PyObject *args); +static PyObject * UnaryPredicate1D___call__( BPy_UnaryPredicate1D *self, PyObject *args); + +/*----------------------UnaryPredicate1D instance definitions ----------------------------*/ +static PyMethodDef BPy_UnaryPredicate1D_methods[] = { + {"getName", ( PyCFunction ) UnaryPredicate1D_getName, METH_NOARGS, ""}, + {"__call__", ( PyCFunction ) UnaryPredicate1D___call__, METH_VARARGS, "" }, + {NULL, NULL, 0, NULL} +}; + +/*-----------------------BPy_UnaryPredicate1D type definition ------------------------------*/ + +PyTypeObject UnaryPredicate1D_Type = { + PyObject_HEAD_INIT( NULL ) + 0, /* ob_size */ + "UnaryPredicate1D", /* tp_name */ + sizeof( BPy_UnaryPredicate1D ), /* tp_basicsize */ + 0, /* tp_itemsize */ + + /* methods */ + (destructor)UnaryPredicate1D___dealloc__, /* tp_dealloc */ + NULL, /* printfunc tp_print; */ + NULL, /* getattrfunc tp_getattr; */ + NULL, /* setattrfunc tp_setattr; */ + NULL, /* tp_compare */ + (reprfunc)UnaryPredicate1D___repr__, /* tp_repr */ + + /* Method suites for standard classes */ + + NULL, /* PyNumberMethods *tp_as_number; */ + NULL, /* PySequenceMethods *tp_as_sequence; */ + NULL, /* PyMappingMethods *tp_as_mapping; */ + + /* More standard operations (here for binary compatibility) */ + + NULL, /* hashfunc tp_hash; */ + NULL, /* ternaryfunc tp_call; */ + NULL, /* reprfunc tp_str; */ + NULL, /* getattrofunc tp_getattro; */ + NULL, /* setattrofunc tp_setattro; */ + + /* Functions to access object as input/output buffer */ + NULL, /* PyBufferProcs *tp_as_buffer; */ + + /*** Flags to define presence of optional/expanded features ***/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* long tp_flags; */ + + NULL, /* char *tp_doc; Documentation string */ + /*** Assigned meaning in release 2.0 ***/ + /* call function for all accessible objects */ + NULL, /* traverseproc tp_traverse; */ + + /* delete references to contained objects */ + NULL, /* inquiry tp_clear; */ + + /*** Assigned meaning in release 2.1 ***/ + /*** rich comparisons ***/ + NULL, /* richcmpfunc tp_richcompare; */ + + /*** weak reference enabler ***/ + 0, /* long tp_weaklistoffset; */ + + /*** Added in release 2.2 ***/ + /* Iterators */ + NULL, /* getiterfunc tp_iter; */ + NULL, /* iternextfunc tp_iternext; */ + + /*** Attribute descriptor and subclassing stuff ***/ + BPy_UnaryPredicate1D_methods, /* struct PyMethodDef *tp_methods; */ + NULL, /* struct PyMemberDef *tp_members; */ + NULL, /* struct PyGetSetDef *tp_getset; */ + NULL, /* struct _typeobject *tp_base; */ + NULL, /* PyObject *tp_dict; */ + NULL, /* descrgetfunc tp_descr_get; */ + NULL, /* descrsetfunc tp_descr_set; */ + 0, /* long tp_dictoffset; */ + (initproc)UnaryPredicate1D___init__, /* initproc tp_init; */ + NULL, /* allocfunc tp_alloc; */ + PyType_GenericNew, /* newfunc tp_new; */ + + /* Low-level free-memory routine */ + NULL, /* freefunc tp_free; */ + + /* For PyObject_IS_GC */ + NULL, /* inquiry tp_is_gc; */ + NULL, /* PyObject *tp_bases; */ + + /* method resolution order */ + NULL, /* PyObject *tp_mro; */ + NULL, /* PyObject *tp_cache; */ + NULL, /* PyObject *tp_subclasses; */ + NULL, /* PyObject *tp_weaklist; */ + NULL +}; + +//-------------------MODULE INITIALIZATION-------------------------------- +PyMODINIT_FUNC UnaryPredicate1D_Init( PyObject *module ) +{ + if( module == NULL ) + return; + + if( PyType_Ready( &UnaryPredicate1D_Type ) < 0 ) + return; + Py_INCREF( &UnaryPredicate1D_Type ); + PyModule_AddObject(module, "UnaryPredicate1D", (PyObject *)&UnaryPredicate1D_Type); +} + +//------------------------INSTANCE METHODS ---------------------------------- + +int UnaryPredicate1D___init__(BPy_UnaryPredicate1D *self, PyObject *args, PyObject *kwds) +{ + return 0; +} + +void UnaryPredicate1D___dealloc__(BPy_UnaryPredicate1D* self) +{ + delete self->up1D; + self->ob_type->tp_free((PyObject*)self); } - PyObject *_wrap_UnaryPredicate1D___call__(PyObject *self , PyObject *args) { +PyObject * UnaryPredicate1D___repr__(BPy_UnaryPredicate1D* self) +{ + return PyString_FromFormat("type: %s - address: %p", self->up1D->getName().c_str(), self->up1D ); } - PyObject *_wrap_disown_UnaryPredicate1D(PyObject *self , PyObject *args) { +PyObject * UnaryPredicate1D_getName( BPy_UnaryPredicate1D *self, PyObject *args) +{ + return PyString_FromString( self->up1D->getName().c_str() ); } +PyObject * UnaryPredicate1D___call__( BPy_UnaryPredicate1D *self, PyObject *args) +{ + PyObject *l; + + if( !PyArg_ParseTuple(args, "O", &l) ) { + cout << "ERROR: UnaryPredicate1D___call__ " << endl; + return NULL; + } + + //TBD + + Py_RETURN_NONE; +} + + +/////////////////////////////////////////////////////////////////////////////////////////// + +#ifdef __cplusplus +} +#endif + + diff --git a/source/blender/freestyle/intern/python/UnaryPredicate1D.h b/source/blender/freestyle/intern/python/UnaryPredicate1D.h new file mode 100644 index 00000000000..8bb33782133 --- /dev/null +++ b/source/blender/freestyle/intern/python/UnaryPredicate1D.h @@ -0,0 +1,35 @@ +#ifndef FREESTYLE_PYTHON_UNARYPREDICATE1D_H +#define FREESTYLE_PYTHON_UNARYPREDICATE1D_H + +#include "../stroke/Predicates1D.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/////////////////////////////////////////////////////////////////////////////////////////// + +#include + +extern PyTypeObject UnaryPredicate1D_Type; + +#define BPy_UnaryPredicate1D_Check(v) \ + ((v)->ob_type == &UnaryPredicate1D_Type) + +/*---------------------------Python BPy_UnaryPredicate1D structure definition----------*/ +typedef struct { + PyObject_HEAD + UnaryPredicate1D *up1D; +} BPy_UnaryPredicate1D; + +/*---------------------------Python BPy_UnaryPredicate1D visible prototypes-----------*/ + +PyMODINIT_FUNC UnaryPredicate1D_Init( PyObject *module ); + +/////////////////////////////////////////////////////////////////////////////////////////// + +#ifdef __cplusplus +} +#endif + +#endif /* FREESTYLE_PYTHON_UNARYPREDICATE1D_H */ -- cgit v1.2.3