diff options
author | Maxime Curioni <maxime.curioni@gmail.com> | 2008-07-18 08:59:07 +0400 |
---|---|---|
committer | Maxime Curioni <maxime.curioni@gmail.com> | 2008-07-18 08:59:07 +0400 |
commit | 21674d2db2dbc932fa87699768c1ebb2f61bc941 (patch) | |
tree | 5c20adaf7165b31ff95e18cf5e1b1adaaab31693 /source | |
parent | d3973dac717da1557a9a8d50f5c13e25ae75eaa8 (diff) |
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<T> and UnaryFunction0D<T> 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.
Diffstat (limited to 'source')
11 files changed, 818 insertions, 39 deletions
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<void> *) self->uf0D)->getName().c_str(), self->uf0D ); +} + + +PyObject * UnaryFunction0D_getName( BPy_UnaryFunction0D *self, PyObject *args) +{ + return PyString_FromString( ((UnaryFunction0D<void> *) 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 <Python.h> + +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<void> *) self->uf1D)->getName().c_str(), self->uf1D ); +} + + +PyObject * UnaryFunction1D_getName( BPy_UnaryFunction1D *self, PyObject *args) +{ + return PyString_FromString( ((UnaryFunction1D<void> *) 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 <Python.h> + +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 <Python.h> + +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 <Python.h> + +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 */ |