diff options
21 files changed, 325 insertions, 131 deletions
diff --git a/source/blender/freestyle/intern/python/BPy_BinaryPredicate0D.cpp b/source/blender/freestyle/intern/python/BPy_BinaryPredicate0D.cpp index 9c3247b30b8..bcd98a42189 100644 --- a/source/blender/freestyle/intern/python/BPy_BinaryPredicate0D.cpp +++ b/source/blender/freestyle/intern/python/BPy_BinaryPredicate0D.cpp @@ -127,6 +127,8 @@ PyMODINIT_FUNC BinaryPredicate0D_Init( PyObject *module ) int BinaryPredicate0D___init__(BPy_BinaryPredicate0D *self, PyObject *args, PyObject *kwds) { self->bp0D = new BinaryPredicate0D(); + self->bp0D->py_bp0D = (PyObject *) self; + return 0; } diff --git a/source/blender/freestyle/intern/python/BPy_BinaryPredicate1D.cpp b/source/blender/freestyle/intern/python/BPy_BinaryPredicate1D.cpp index 545807fc277..9f7e0359ec8 100644 --- a/source/blender/freestyle/intern/python/BPy_BinaryPredicate1D.cpp +++ b/source/blender/freestyle/intern/python/BPy_BinaryPredicate1D.cpp @@ -159,6 +159,7 @@ PyMODINIT_FUNC BinaryPredicate1D_Init( PyObject *module ) int BinaryPredicate1D___init__(BPy_BinaryPredicate1D *self, PyObject *args, PyObject *kwds) { self->bp1D = new BinaryPredicate1D(); + self->bp1D->py_bp1D = (PyObject *) self; return 0; } diff --git a/source/blender/freestyle/intern/python/BPy_Convert.cpp b/source/blender/freestyle/intern/python/BPy_Convert.cpp index d7b6fa8bd33..0b136b7702f 100644 --- a/source/blender/freestyle/intern/python/BPy_Convert.cpp +++ b/source/blender/freestyle/intern/python/BPy_Convert.cpp @@ -11,6 +11,7 @@ #include "Interface0D/BPy_ViewVertex.h" #include "BPy_Interface1D.h" #include "Interface1D/BPy_FEdge.h" +#include "Interface1D/BPy_Stroke.h" #include "Interface1D/BPy_ViewEdge.h" #include "BPy_Nature.h" #include "BPy_MediumType.h" @@ -115,6 +116,14 @@ PyObject * BPy_Nature_from_Nature( unsigned short n ) { return py_n; } +PyObject * BPy_Stroke_from_Stroke( Stroke& s ) { + PyObject *py_s = Stroke_Type.tp_new( &Stroke_Type, 0, 0 ); + ((BPy_Stroke *) py_s)->s = new Stroke( s ); + ((BPy_Stroke *) py_s)->py_if1D.if1D = ((BPy_Stroke *) py_s)->s; + + return py_s; +} + PyObject * BPy_StrokeAttribute_from_StrokeAttribute( StrokeAttribute& sa ) { PyObject *py_sa = StrokeAttribute_Type.tp_new( &StrokeAttribute_Type, 0, 0 ); ((BPy_StrokeAttribute *) py_sa)->sa = new StrokeAttribute( sa ); diff --git a/source/blender/freestyle/intern/python/BPy_Convert.h b/source/blender/freestyle/intern/python/BPy_Convert.h index 9e743f4b233..4bfaf4c1e17 100644 --- a/source/blender/freestyle/intern/python/BPy_Convert.h +++ b/source/blender/freestyle/intern/python/BPy_Convert.h @@ -80,6 +80,7 @@ PyObject * BPy_FrsMaterial_from_Material( Material& m ); PyObject * BPy_Nature_from_Nature( unsigned short n ); PyObject * BPy_MediumType_from_MediumType( int n ); PyObject * BPy_SShape_from_SShape( SShape& ss ); +PyObject * BPy_Stroke_from_Stroke( Stroke& s ); PyObject * BPy_StrokeAttribute_from_StrokeAttribute( StrokeAttribute& sa ); PyObject * BPy_StrokeVertex_from_StrokeVertex( StrokeVertex& sv ); PyObject * BPy_SVertex_from_SVertex( SVertex& sv ); diff --git a/source/blender/freestyle/intern/python/BPy_Operators.cpp b/source/blender/freestyle/intern/python/BPy_Operators.cpp index 850b4cb5bad..ab64f5bc6eb 100644 --- a/source/blender/freestyle/intern/python/BPy_Operators.cpp +++ b/source/blender/freestyle/intern/python/BPy_Operators.cpp @@ -164,21 +164,19 @@ PyObject * Operators_select(BPy_Operators* self, PyObject *args) Py_RETURN_NONE; } - UnaryPredicate1D *up1D = ((BPy_UnaryPredicate1D *) obj)->up1D; - if( PyObject_HasAttrString( obj, "__call__") ) - up1D->setPythonObject( obj ); - - Operators::select(*up1D); + Operators::select(*( ((BPy_UnaryPredicate1D *) obj)->up1D )); Py_RETURN_NONE; } +// CHANGE: first parameter is a chaining iterator, not just a view + PyObject * Operators_chain(BPy_Operators* self, PyObject *args) { PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0; if(!( PyArg_ParseTuple(args, "OO|O", &obj1, &obj2, &obj3) && - BPy_ViewEdgeIterator_Check(obj1) && ((BPy_ViewEdgeIterator *) obj1)->ve_it && + BPy_ChainingIterator_Check(obj1) && ((BPy_ChainingIterator *) obj1)->c_it && BPy_UnaryPredicate1D_Check(obj2) && ((BPy_UnaryPredicate1D *) obj2)->up1D )) { cout << "ERROR: Operators_chain" << endl; Py_RETURN_NONE; @@ -186,12 +184,13 @@ PyObject * Operators_chain(BPy_Operators* self, PyObject *args) if( !obj3 ) { - Operators::chain( *( ((BPy_ViewEdgeIterator *) obj1)->ve_it ), + Operators::chain( *( ((BPy_ChainingIterator *) obj1)->c_it ), *( ((BPy_UnaryPredicate1D *) obj2)->up1D ) ); } else if( BPy_UnaryFunction1DVoid_Check(obj3) && ((BPy_UnaryFunction1DVoid *) obj3)->uf1D_void ) { - Operators::chain( *( ((BPy_ViewEdgeIterator *) obj1)->ve_it ), + + Operators::chain( *( ((BPy_ChainingIterator *) obj1)->c_it ), *( ((BPy_UnaryPredicate1D *) obj2)->up1D ), *( ((BPy_UnaryFunction1DVoid *) obj3)->uf1D_void ) ); @@ -209,7 +208,7 @@ PyObject * Operators_bidirectionalChain(BPy_Operators* self, PyObject *args) cout << "ERROR: Operators_bidirectionalChain" << endl; Py_RETURN_NONE; } - + if( !obj2 ) { Operators::bidirectionalChain( *( ((BPy_ChainingIterator *) obj1)->c_it ) ); @@ -234,7 +233,7 @@ PyObject * Operators_sequentialSplit(BPy_Operators* self, PyObject *args) cout << "ERROR: Operators_sequentialSplit" << endl; Py_RETURN_NONE; } - + if( obj2 && BPy_UnaryPredicate0D_Check(obj2) ) { Operators::sequentialSplit( *( ((BPy_UnaryPredicate0D *) obj1)->up0D ), @@ -266,7 +265,7 @@ PyObject * Operators_recursiveSplit(BPy_Operators* self, PyObject *args) if( BPy_UnaryPredicate1D_Check(obj2) && ((BPy_UnaryPredicate1D *) obj2)->up1D ) { float f = ( obj3 && PyFloat_Check(obj3) ) ? PyFloat_AsDouble(obj3) : 0.0; - + Operators::recursiveSplit( *( ((BPy_UnaryFunction0DDouble *) obj1)->uf0D_double ), *( ((BPy_UnaryPredicate1D *) obj2)->up1D ), f ); @@ -313,8 +312,9 @@ PyObject * Operators_create(BPy_Operators* self, PyObject *args) vector<StrokeShader *> shaders; for( int i = 0; i < PyList_Size(obj2); i++) { PyObject *py_ss = PyList_GetItem(obj2,i); - if( BPy_StrokeShader_Check(py_ss) ) - shaders.push_back( ((BPy_StrokeShader *) py_ss)->ss ); + + if( BPy_StrokeShader_Check(py_ss) ) + shaders.push_back( ((BPy_StrokeShader *) py_ss)->ss ); } Operators::create( *( ((BPy_UnaryPredicate1D *) obj1)->up1D ), shaders); diff --git a/source/blender/freestyle/intern/python/BPy_StrokeShader.cpp b/source/blender/freestyle/intern/python/BPy_StrokeShader.cpp index a6d2ae1e512..3b756b40d9b 100644 --- a/source/blender/freestyle/intern/python/BPy_StrokeShader.cpp +++ b/source/blender/freestyle/intern/python/BPy_StrokeShader.cpp @@ -254,6 +254,7 @@ PyMODINIT_FUNC StrokeShader_Init( PyObject *module ) int StrokeShader___init__(BPy_StrokeShader *self, PyObject *args, PyObject *kwds) { self->ss = new StrokeShader(); + self->ss->py_ss = (PyObject *) self; return 0; } diff --git a/source/blender/freestyle/intern/python/BPy_UnaryFunction0D.h b/source/blender/freestyle/intern/python/BPy_UnaryFunction0D.h index 0ab0bfbdc2e..d95230ecccd 100644 --- a/source/blender/freestyle/intern/python/BPy_UnaryFunction0D.h +++ b/source/blender/freestyle/intern/python/BPy_UnaryFunction0D.h @@ -18,6 +18,7 @@ extern PyTypeObject UnaryFunction0D_Type; /*---------------------------Python BPy_UnaryFunction0D structure definition----------*/ typedef struct { PyObject_HEAD + PyObject *py_uf0D; } BPy_UnaryFunction0D; /*---------------------------Python BPy_UnaryFunction0D visible prototypes-----------*/ diff --git a/source/blender/freestyle/intern/python/BPy_UnaryFunction1D.h b/source/blender/freestyle/intern/python/BPy_UnaryFunction1D.h index f33fcf48da4..571ef8a5d25 100644 --- a/source/blender/freestyle/intern/python/BPy_UnaryFunction1D.h +++ b/source/blender/freestyle/intern/python/BPy_UnaryFunction1D.h @@ -18,6 +18,7 @@ extern PyTypeObject UnaryFunction1D_Type; /*---------------------------Python BPy_UnaryFunction1D structure definition----------*/ typedef struct { PyObject_HEAD + PyObject *py_uf1D; } BPy_UnaryFunction1D; /*---------------------------Python BPy_UnaryFunction1D visible prototypes-----------*/ diff --git a/source/blender/freestyle/intern/python/BPy_UnaryPredicate0D.cpp b/source/blender/freestyle/intern/python/BPy_UnaryPredicate0D.cpp index 4fef63eae9b..db708c7830b 100644 --- a/source/blender/freestyle/intern/python/BPy_UnaryPredicate0D.cpp +++ b/source/blender/freestyle/intern/python/BPy_UnaryPredicate0D.cpp @@ -139,6 +139,7 @@ PyMODINIT_FUNC UnaryPredicate0D_Init( PyObject *module ) int UnaryPredicate0D___init__(BPy_UnaryPredicate0D *self, PyObject *args, PyObject *kwds) { self->up0D = new UnaryPredicate0D(); + self->up0D->py_up0D = (PyObject *) self; return 0; } diff --git a/source/blender/freestyle/intern/python/BPy_UnaryPredicate1D.cpp b/source/blender/freestyle/intern/python/BPy_UnaryPredicate1D.cpp index 14eb041c480..f2b2c7b9b53 100644 --- a/source/blender/freestyle/intern/python/BPy_UnaryPredicate1D.cpp +++ b/source/blender/freestyle/intern/python/BPy_UnaryPredicate1D.cpp @@ -181,6 +181,7 @@ PyMODINIT_FUNC UnaryPredicate1D_Init( PyObject *module ) int UnaryPredicate1D___init__(BPy_UnaryPredicate1D *self, PyObject *args, PyObject *kwds) { self->up1D = new UnaryPredicate1D(); + self->up1D->py_up1D = (PyObject *) self; return 0; } diff --git a/source/blender/freestyle/intern/python/Director.cpp b/source/blender/freestyle/intern/python/Director.cpp index 6acdc665a0c..d3aff4a65f2 100644 --- a/source/blender/freestyle/intern/python/Director.cpp +++ b/source/blender/freestyle/intern/python/Director.cpp @@ -2,11 +2,85 @@ #include "BPy_Convert.h" -bool director_BPy_UnaryPredicate1D___call__( PyObject *py_up1D, Interface1D& if1D) { - cout << "Polymorphism works" << endl; +#include "BPy_BinaryPredicate0D.h" +#include "BPy_BinaryPredicate1D.h" +#include "BPy_UnaryFunction0D.h" +#include "BPy_UnaryFunction1D.h" +#include "BPy_UnaryPredicate0D.h" +#include "BPy_UnaryPredicate1D.h" +#include "BPy_StrokeShader.h" +#include "Iterator/BPy_ChainingIterator.h" +#include "Interface1D/BPy_Stroke.h" +#include "Interface1D/BPy_ViewEdge.h" - PyObject *method = PyObject_GetAttrString( py_up1D, "__call__"); - PyObject *result = PyObject_CallFunction(method, "O", BPy_Interface1D_from_Interface1D(if1D) ); +// BinaryPredicate0D: __call__ +bool Director_BPy_BinaryPredicate0D___call__( PyObject *obj, Interface0D& i1, Interface0D& i2) { + PyObject *result = PyObject_CallMethod( obj, "__call__", "OO", BPy_Interface0D_from_Interface0D(i1), BPy_Interface0D_from_Interface0D(i2) ); + + return bool_from_PyBool(result); +} + + +// BinaryPredicate1D: __call__ +bool Director_BPy_BinaryPredicate1D___call__( PyObject *obj, Interface1D& i1, Interface1D& i2) { + PyObject *result = PyObject_CallMethod( obj, "__call__", "OO", BPy_Interface1D_from_Interface1D(i1), BPy_Interface1D_from_Interface1D(i2) ); + + return bool_from_PyBool(result); +} + + +// UnaryPredicate0D: __call__ +bool Director_BPy_UnaryPredicate0D___call__( PyObject *obj, Interface0DIterator& if0D_it) { + PyObject *result = PyObject_CallMethod( obj, "__call__", "O", BPy_Interface0DIterator_from_Interface0DIterator(if0D_it) ); + + return bool_from_PyBool(result); +} + + +// UnaryPredicate1D: __call__ +bool Director_BPy_UnaryPredicate1D___call__( PyObject *obj, Interface1D& if1D) { + PyObject *result = PyObject_CallMethod( obj, "__call__", "O", BPy_Interface1D_from_Interface1D(if1D) ); return bool_from_PyBool(result); } + + +// StrokeShader: shade +void Director_BPy_StrokeShader_shade( PyObject *obj, Stroke& s) { + PyObject_CallMethod( obj, "shade", "O", BPy_Stroke_from_Stroke(s) ); +} + +// ChainingIterator: init, traverse +void Director_BPy_ChainingIterator_init( PyObject *obj ) { + PyObject_CallMethod( obj, "init", "", 0 ); +} + +ViewEdge * Director_BPy_ChainingIterator_traverse( PyObject *obj, AdjacencyIterator& a_it ) { + PyObject *result = PyObject_CallMethod( obj, "traverse", "O", BPy_AdjacencyIterator_from_AdjacencyIterator(a_it) ); + + return ((BPy_ViewEdge *) result)->ve; +} + + +// BPy_UnaryFunction{0D,1D}: __call__ +// BPy_UnaryFunction0DDouble +// BPy_UnaryFunction0DEdgeNature +// BPy_UnaryFunction0DFloat +// BPy_UnaryFunction0DId +// BPy_UnaryFunction0DMaterial +// BPy_UnaryFunction0DUnsigned +// BPy_UnaryFunction0DVec2f +// BPy_UnaryFunction0DVec3f +// BPy_UnaryFunction0DVectorViewShape +// BPy_UnaryFunction0DViewShape + +// BPy_UnaryFunction1DDouble +// BPy_UnaryFunction1DEdgeNature +// BPy_UnaryFunction1DFloat +// BPy_UnaryFunction1DUnsigned +// BPy_UnaryFunction1DVec2f +// BPy_UnaryFunction1DVec3f +// BPy_UnaryFunction1DVectorViewShape +// BPy_UnaryFunction1DVoid + + diff --git a/source/blender/freestyle/intern/python/Director.h b/source/blender/freestyle/intern/python/Director.h index 7114b124ffb..95ab16047a8 100644 --- a/source/blender/freestyle/intern/python/Director.h +++ b/source/blender/freestyle/intern/python/Director.h @@ -1,34 +1,65 @@ #ifndef FREESTYLE_PYTHON_DIRECTOR # define FREESTYLE_PYTHON_DIRECTOR -#include "../view_map/Interface1D.h" +class Interface0D; +class Interface1D; +class Interface0DIterator; +class Stroke; +class AdjacencyIterator; +class ViewEdge; #ifdef __cplusplus extern "C" { #endif -/////////////////////////////////////////////////////////////////////////////////////////// - #include <Python.h> -// SWIG directors -// ---------------------------- -// ViewEdgeInternal::ViewEdgeIterator; -// ChainingIterator; -// ChainSilhouetteIterator; -// ChainPredicateIterator; -// UnaryPredicate0D; -// UnaryPredicate1D; -// BinaryPredicate1D; -// StrokeShader; - -bool director_BPy_UnaryPredicate1D___call__( PyObject *py_up1D, Interface1D& if1D); - -/////////////////////////////////////////////////////////////////////////////////////////// - #ifdef __cplusplus } #endif +// BinaryPredicate0D: __call__ +bool Director_BPy_BinaryPredicate0D___call__( PyObject *obj, Interface0D& i1, Interface0D& i2); + +// BinaryPredicate1D: __call__ +bool Director_BPy_BinaryPredicate1D___call__( PyObject *obj, Interface1D& i1, Interface1D& i2); + +// UnaryPredicate0D: __call__ +bool Director_BPy_UnaryPredicate0D___call__( PyObject *obj, Interface0DIterator& if0D_it); + +// UnaryPredicate1D: __call__ +bool Director_BPy_UnaryPredicate1D___call__( PyObject *obj, Interface1D& if1D); + +// StrokeShader: shade +void Director_BPy_StrokeShader_shade( PyObject *obj, Stroke& s); + +// ChainingIterator: init, traverse +void Director_BPy_ChainingIterator_init( PyObject *obj ); +ViewEdge * Director_BPy_ChainingIterator_traverse( PyObject *obj, AdjacencyIterator& a_it ); + +// BPy_UnaryFunction0DDouble +double Director_BPy_UnaryFunction0DDouble___call__( PyObject *obj, Interface0DIterator& if0D_it); +// BPy_UnaryFunction0DEdgeNature +// BPy_UnaryFunction0DFloat +// BPy_UnaryFunction0DId +// BPy_UnaryFunction0DMaterial +// BPy_UnaryFunction0DUnsigned +// BPy_UnaryFunction0DVec2f +// BPy_UnaryFunction0DVec3f +// BPy_UnaryFunction0DVectorViewShape +// BPy_UnaryFunction0DViewShape + +// BPy_UnaryFunction1DDouble +// BPy_UnaryFunction1DEdgeNature +// BPy_UnaryFunction1DFloat +// BPy_UnaryFunction1DUnsigned +// BPy_UnaryFunction1DVec2f +// BPy_UnaryFunction1DVec3f +// BPy_UnaryFunction1DVectorViewShape +// BPy_UnaryFunction1DVoid +void Director_BPy_UnaryFunction1DVoid___call__( PyObject *obj, Interface1D& if1D); + + + #endif // FREESTYLE_PYTHON_DIRECTOR diff --git a/source/blender/freestyle/intern/python/Iterator/BPy_ChainingIterator.cpp b/source/blender/freestyle/intern/python/Iterator/BPy_ChainingIterator.cpp index 525b0697fa7..f33fe0e17bc 100644 --- a/source/blender/freestyle/intern/python/Iterator/BPy_ChainingIterator.cpp +++ b/source/blender/freestyle/intern/python/Iterator/BPy_ChainingIterator.cpp @@ -139,6 +139,8 @@ int ChainingIterator___init__(BPy_ChainingIterator *self, PyObject *args ) self->py_ve_it.ve_it = self->c_it; self->py_ve_it.py_it.it = self->c_it; + self->c_it->py_c_it = (PyObject *) self; + return 0; } diff --git a/source/blender/freestyle/intern/stroke/ChainingIterators.h b/source/blender/freestyle/intern/stroke/ChainingIterators.h index b01c895d89a..1f33f99db67 100755 --- a/source/blender/freestyle/intern/stroke/ChainingIterators.h +++ b/source/blender/freestyle/intern/stroke/ChainingIterators.h @@ -36,6 +36,8 @@ #include "../system/Iterator.h" //soc +# include "../python/Director.h" + //using namespace ViewEdgeInternal; // @@ -135,6 +137,9 @@ protected: bool _increment; //true if we're currently incrementing, false when decrementing public: + + PyObject *py_c_it; + /*! Builds a Chaining Iterator from the first ViewEdge used for iteration * and its orientation. * \param iRestrictToSelection @@ -154,6 +159,7 @@ public: _restrictToSelection = iRestrictToSelection; _restrictToUnvisited = iRestrictToUnvisited; _increment = true; + py_c_it = 0; } /*! Copy constructor */ @@ -162,6 +168,7 @@ public: _restrictToSelection = brother._restrictToSelection; _restrictToUnvisited = brother._restrictToUnvisited; _increment = brother._increment; + py_c_it = brother.py_c_it; } /*! Returns the string "ChainingIterator" */ @@ -176,7 +183,16 @@ public: * history information that you * might want to keep. */ - virtual void init(){} + virtual void init() { + string name( py_c_it ? PyString_AsString(PyObject_CallMethod(py_c_it, "getExactTypeName", "")) : getExactTypeName() ); + + if( py_c_it && PyObject_HasAttrString(py_c_it, "init") ) { + Director_BPy_ChainingIterator_init( py_c_it ); + } else { + cerr << "Warning: " << name << " method init() not implemented" << endl; + } + + } /*! This method iterates over the potential next * ViewEdges and returns the one that will be @@ -190,10 +206,16 @@ public: * rules by only iterating over the valid ViewEdges. */ virtual ViewEdge * traverse(const AdjacencyIterator &it){ - cerr << "Warning: the traverse method was not defined" << endl; - return 0; + string name( py_c_it ? PyString_AsString(PyObject_CallMethod(py_c_it, "getExactTypeName", "")) : getExactTypeName() ); + + if( py_c_it && PyObject_HasAttrString(py_c_it, "traverse") ) { + return Director_BPy_ChainingIterator_traverse(py_c_it, const_cast<AdjacencyIterator &>(it) ); + } else { + cerr << "Warning: the " << name << " traverse method was not defined" << endl; + return 0; + } } - + /* accessors */ /*! Returns true if the orientation of the current ViewEdge * corresponds to its natural orientation @@ -274,6 +296,8 @@ public: */ virtual ViewEdge * traverse(const AdjacencyIterator& it); + /*! Inits the iterator context */ + virtual void init() {} }; // @@ -368,7 +392,11 @@ public: * followed next. * When reaching the end of a chain, 0 is returned. */ - virtual ViewEdge * traverse(const AdjacencyIterator &it); + virtual ViewEdge * traverse(const AdjacencyIterator &it); + + /*! Inits the iterator context */ + virtual void init() {} + }; #endif // CHAININGITERATORS_H diff --git a/source/blender/freestyle/intern/stroke/Predicates0D.h b/source/blender/freestyle/intern/stroke/Predicates0D.h index 4c2dfacdf98..0318c1742ec 100755 --- a/source/blender/freestyle/intern/stroke/Predicates0D.h +++ b/source/blender/freestyle/intern/stroke/Predicates0D.h @@ -32,6 +32,8 @@ # include "../view_map/Functions0D.h" +# include "../python/Director.h" + // // UnaryPredicate0D (base class for predicates in 0D) // @@ -48,8 +50,11 @@ class UnaryPredicate0D { public: + + PyObject *py_up0D; + /*! Default constructor. */ - UnaryPredicate0D() {} + UnaryPredicate0D() { py_up0D = 0; } /*! Destructor. */ virtual ~UnaryPredicate0D() {} /*! Returns the string of the name @@ -68,9 +73,16 @@ public: * false otherwise. */ virtual bool operator()(Interface0DIterator& it) { - cerr << "Warning: operator() not implemented" << endl; - return false; + string name( py_up0D ? PyString_AsString(PyObject_CallMethod(py_up0D, "getName", "")) : getName() ); + + if( py_up0D && PyObject_HasAttrString(py_up0D, "__call__") ) { + return Director_BPy_UnaryPredicate0D___call__(py_up0D, it); + } else { + cerr << "Warning: " << name << " operator() not implemented" << endl; + return false; + } } + }; @@ -88,8 +100,11 @@ public: class BinaryPredicate0D { public: + + PyObject *py_bp0D; + /*! Default constructor. */ - BinaryPredicate0D() {} + BinaryPredicate0D() { py_bp0D = 0; } /*! Destructor. */ virtual ~BinaryPredicate0D() {} /*! Returns the string of the name of the @@ -108,9 +123,16 @@ public: * \return true or false. */ virtual bool operator()(Interface0D& inter1, Interface0D& inter2) { - cerr << "Warning: operator() not implemented" << endl; - return false; + string name( py_bp0D ? PyString_AsString(PyObject_CallMethod(py_bp0D, "getName", "")) : getName() ); + + if( py_bp0D && PyObject_HasAttrString(py_bp0D, "__call__") ) { + return Director_BPy_BinaryPredicate0D___call__(py_bp0D, inter1, inter2); + } else { + cerr << "Warning: " << name << " operator() not implemented" << endl; + return false; + } } + }; diff --git a/source/blender/freestyle/intern/stroke/Predicates1D.h b/source/blender/freestyle/intern/stroke/Predicates1D.h index 98148361bb7..8c6f5a9bfa4 100755 --- a/source/blender/freestyle/intern/stroke/Predicates1D.h +++ b/source/blender/freestyle/intern/stroke/Predicates1D.h @@ -58,9 +58,7 @@ public: PyObject *py_up1D; /*! Default constructor. */ - UnaryPredicate1D() { - py_up1D = 0; - } + UnaryPredicate1D() { py_up1D = 0; } /*! Destructor. */ virtual ~UnaryPredicate1D() {} /*! Returns the string of the name @@ -78,17 +76,16 @@ public: * false otherwise. */ virtual bool operator()(Interface1D& inter) { + string name( py_up1D ? PyString_AsString(PyObject_CallMethod(py_up1D, "getName", "")) : getName() ); - if( py_up1D ) { - return director_BPy_UnaryPredicate1D___call__(py_up1D, inter); + if( py_up1D && PyObject_HasAttrString(py_up1D, "__call__")) { + return Director_BPy_UnaryPredicate1D___call__(py_up1D, inter); } else { - cerr << "Warning: operator() not implemented" << endl; - return false; + cerr << "Warning: " << name << " operator() not implemented" << endl; + return false; } } - inline void setPythonObject(PyObject *_py_up1D) { py_up1D = _py_up1D; } - }; @@ -106,8 +103,11 @@ public: class BinaryPredicate1D { public: + + PyObject *py_bp1D; + /*! Default constructor. */ - BinaryPredicate1D() {} + BinaryPredicate1D() { py_bp1D = 0; } /*! Destructor. */ virtual ~BinaryPredicate1D() {} /*! Returns the string of the name of the @@ -125,9 +125,16 @@ public: * \return true or false. */ virtual bool operator()(Interface1D& inter1, Interface1D& inter2) { - cerr << "Warning: operator() not implemented" << endl; - return false; + string name( py_bp1D ? PyString_AsString(PyObject_CallMethod(py_bp1D, "getName", "")) : getName() ); + + if( py_bp1D && py_bp1D && PyObject_HasAttrString(py_bp1D, "__call__") ) { + return Director_BPy_BinaryPredicate1D___call__(py_bp1D, inter1, inter2); + } else { + cerr << "Warning: " << name << " operator() not implemented" << endl; + return false; + } } + }; diff --git a/source/blender/freestyle/intern/stroke/Stroke.h b/source/blender/freestyle/intern/stroke/Stroke.h index 8e4e5e24a2c..3df57341e5f 100755 --- a/source/blender/freestyle/intern/stroke/Stroke.h +++ b/source/blender/freestyle/intern/stroke/Stroke.h @@ -38,6 +38,7 @@ # include "../view_map/Interface1D.h" # include "../system/StringUtils.h" + // // StrokeAttribute // diff --git a/source/blender/freestyle/intern/stroke/StrokeShader.h b/source/blender/freestyle/intern/stroke/StrokeShader.h index fa1289f6e0f..f92895564d8 100755 --- a/source/blender/freestyle/intern/stroke/StrokeShader.h +++ b/source/blender/freestyle/intern/stroke/StrokeShader.h @@ -33,6 +33,8 @@ # include <iostream> # include <vector> +# include "../python/Director.h" + // // StrokeShader base class // @@ -69,8 +71,11 @@ class Stroke; class LIB_STROKE_EXPORT StrokeShader { public: + + PyObject *py_ss; + /*! Default constructor. */ - StrokeShader() {} + StrokeShader() { py_ss = 0; } /*! Destructor. */ virtual ~StrokeShader() {} /*! Returns the string corresponding to the @@ -111,7 +116,13 @@ public: * as Color, Thickness, Geometry...) */ virtual void shade(Stroke& ioStroke) const { - cerr << "Warning: method shade() not implemented" << endl; + string name( py_ss ? PyString_AsString(PyObject_CallMethod(py_ss, "getName", "")) : getName() ); + + if( py_ss && PyObject_HasAttrString(py_ss, "shade") ) { + return Director_BPy_StrokeShader_shade(py_ss, ioStroke); + } else { + cerr << "Warning: " << name << " method shade() not implemented" << endl; + } } }; diff --git a/source/blender/freestyle/intern/view_map/Functions0D.h b/source/blender/freestyle/intern/view_map/Functions0D.h index 3160546da2f..1ad35da8d91 100755 --- a/source/blender/freestyle/intern/view_map/Functions0D.h +++ b/source/blender/freestyle/intern/view_map/Functions0D.h @@ -90,7 +90,7 @@ public: * \return the result of the function of type T. */ virtual T operator()(Interface0DIterator& iter) { - cerr << "Warning: operator() not implemented" << endl; + cerr << "Warning: UnaryFunction0D operator() not implemented" << endl; return T(); } }; diff --git a/source/blender/freestyle/intern/view_map/Functions1D.h b/source/blender/freestyle/intern/view_map/Functions1D.h index c92d12ff330..072733b985d 100755 --- a/source/blender/freestyle/intern/view_map/Functions1D.h +++ b/source/blender/freestyle/intern/view_map/Functions1D.h @@ -92,7 +92,7 @@ public: * \return the result of the function of type T. */ virtual T operator()(Interface1D& inter) { - cerr << "Warning: operator() not implemented" << endl; + cerr << "Warning: UnaryFunction1D operator() not implemented" << endl; return T(0); } /*! Sets the integration method */ diff --git a/source/blender/freestyle/style_modules_blender/freestyle_init.py b/source/blender/freestyle/style_modules_blender/freestyle_init.py index 06b8f933114..e4ad8a9f769 100644 --- a/source/blender/freestyle/style_modules_blender/freestyle_init.py +++ b/source/blender/freestyle/style_modules_blender/freestyle_init.py @@ -49,10 +49,10 @@ class StrokeShader(Blender.Freestyle.StrokeShader): pass class UnaryFunction0D(Blender.Freestyle.UnaryFunction0D): - def __call__(*args): return Blender.Freestyle.UnaryFunction0D.__call__(*args) + pass class UnaryFunction1D(Blender.Freestyle.UnaryFunction1D): - def __call__(*args): return Blender.Freestyle.UnaryFunction1D.__call__(*args) + pass class UnaryPredicate0D(Blender.Freestyle.UnaryPredicate0D): pass @@ -67,19 +67,19 @@ class ViewShape(Blender.Freestyle.ViewShape): pass class FalseBP1D(Blender.Freestyle.FalseBP1D): - def __call__(*args): return Blender.Freestyle.FalseBP1D.__call__(*args) + pass class Length2DBP1D(Blender.Freestyle.Length2DBP1D): - def __call__(*args): return Blender.Freestyle.Length2DBP1D.__call__(*args) + pass class SameShapeIdBP1D(Blender.Freestyle.SameShapeIdBP1D): - def __call__(*args): return Blender.Freestyle.SameShapeIdBP1D.__call__(*args) + pass class TrueBP1D(Blender.Freestyle.TrueBP1D): - def __call__(*args): return Blender.Freestyle.TrueBP1D.__call__(*args) + pass class ViewMapGradientNormBP1D(Blender.Freestyle.ViewMapGradientNormBP1D): - def __call__(*args): return Blender.Freestyle.ViewMapGradientNormBP1D.__call__(*args) + pass class CurvePoint(Blender.Freestyle.CurvePoint): pass @@ -250,37 +250,37 @@ class UnaryFunction1DVoid(Blender.Freestyle.UnaryFunction1DVoid): pass class FalseUP0D(Blender.Freestyle.FalseUP0D): - def __call__(*args): return Blender.Freestyle.FalseUP0D.__call__(*args) + pass class TrueUP0D(Blender.Freestyle.TrueUP0D): - def __call__(*args): return Blender.Freestyle.TrueUP0D.__call__(*args) + pass class ContourUP1D(Blender.Freestyle.ContourUP1D): - def __call__(*args): return Blender.Freestyle.ContourUP1D.__call__(*args) + pass class DensityLowerThanUP1D(Blender.Freestyle.DensityLowerThanUP1D): - def __call__(*args): return Blender.Freestyle.DensityLowerThanUP1D.__call__(*args) + pass class EqualToChainingTimeStampUP1D(Blender.Freestyle.EqualToChainingTimeStampUP1D): - def __call__(*args): return Blender.Freestyle.EqualToChainingTimeStampUP1D.__call__(*args) + pass class EqualToTimeStampUP1D(Blender.Freestyle.EqualToTimeStampUP1D): - def __call__(*args): return Blender.Freestyle.EqualToTimeStampUP1D.__call__(*args) + pass class ExternalContourUP1D(Blender.Freestyle.ExternalContourUP1D): - def __call__(*args): return Blender.Freestyle.ExternalContourUP1D.__call__(*args) + pass class FalseUP1D(Blender.Freestyle.FalseUP1D): - def __call__(*args): return Blender.Freestyle.FalseUP1D.__call__(*args) + pass class QuantitativeInvisibilityUP1D(Blender.Freestyle.QuantitativeInvisibilityUP1D): - def __call__(*args): return Blender.Freestyle.QuantitativeInvisibilityUP1D.__call__(*args) + pass class ShapeUP1D(Blender.Freestyle.ShapeUP1D): - def __call__(*args): return Blender.Freestyle.ShapeUP1D.__call__(*args) + pass class TrueUP1D(Blender.Freestyle.TrueUP1D): - def __call__(*args): return Blender.Freestyle.TrueUP1D.__call__(*args) + pass class StrokeVertex(Blender.Freestyle.StrokeVertex): pass @@ -301,155 +301,155 @@ class FEdgeSmooth(Blender.Freestyle.FEdgeSmooth): pass class Curvature2DAngleF0D(Blender.Freestyle.Curvature2DAngleF0D): - def __call__(*args): return Blender.Freestyle.Curvature2DAngleF0D.__call__(*args) + pass class DensityF0D(Blender.Freestyle.DensityF0D): - def __call__(*args): return Blender.Freestyle.DensityF0D.__call__(*args) + pass class GetProjectedXF0D(Blender.Freestyle.GetProjectedXF0D): - def __call__(*args): return Blender.Freestyle.GetProjectedXF0D.__call__(*args) + pass class GetProjectedYF0D(Blender.Freestyle.GetProjectedYF0D): - def __call__(*args): return Blender.Freestyle.GetProjectedYF0D.__call__(*args) + pass class GetProjectedZF0D(Blender.Freestyle.GetProjectedZF0D): - def __call__(*args): return Blender.Freestyle.GetProjectedZF0D.__call__(*args) + pass class GetXF0D(Blender.Freestyle.GetXF0D): - def __call__(*args): return Blender.Freestyle.GetXF0D.__call__(*args) + pass class GetYF0D(Blender.Freestyle.GetYF0D): - def __call__(*args): return Blender.Freestyle.GetYF0D.__call__(*args) + pass class GetZF0D(Blender.Freestyle.GetZF0D): - def __call__(*args): return Blender.Freestyle.GetZF0D.__call__(*args) + pass class LocalAverageDepthF0D(Blender.Freestyle.LocalAverageDepthF0D): - def __call__(*args): return Blender.Freestyle.LocalAverageDepthF0D.__call__(*args) + pass class ZDiscontinuityF0D(Blender.Freestyle.ZDiscontinuityF0D): - def __call__(*args): return Blender.Freestyle.ZDiscontinuityF0D.__call__(*args) + pass class GetCurvilinearAbscissaF0D(Blender.Freestyle.GetCurvilinearAbscissaF0D): - def __call__(*args): return Blender.Freestyle.GetCurvilinearAbscissaF0D.__call__(*args) + pass class GetParameterF0D(Blender.Freestyle.GetParameterF0D): - def __call__(*args): return Blender.Freestyle.GetParameterF0D.__call__(*args) + pass class GetViewMapGradientNormF0D(Blender.Freestyle.GetViewMapGradientNormF0D): - def __call__(*args): return Blender.Freestyle.GetViewMapGradientNormF0D.__call__(*args) + pass class ReadCompleteViewMapPixelF0D(Blender.Freestyle.ReadCompleteViewMapPixelF0D): - def __call__(*args): return Blender.Freestyle.ReadCompleteViewMapPixelF0D.__call__(*args) + pass class ReadMapPixelF0D(Blender.Freestyle.ReadMapPixelF0D): - def __call__(*args): return Blender.Freestyle.ReadMapPixelF0D.__call__(*args) + pass class ReadSteerableViewMapPixelF0D(Blender.Freestyle.ReadSteerableViewMapPixelF0D): - def __call__(*args): return Blender.Freestyle.ReadSteerableViewMapPixelF0D.__call__(*args) + pass class ShapeIdF0D(Blender.Freestyle.ShapeIdF0D): - def __call__(*args): return Blender.Freestyle.ShapeIdF0D.__call__(*args) + pass class MaterialF0D(Blender.Freestyle.MaterialF0D): - def __call__(*args): return Blender.Freestyle.MaterialF0D.__call__(*args) + pass class CurveNatureF0D(Blender.Freestyle.CurveNatureF0D): - def __call__(*args): return Blender.Freestyle.CurveNatureF0D.__call__(*args) + pass class QuantitativeInvisibilityF0D(Blender.Freestyle.QuantitativeInvisibilityF0D): - def __call__(*args): return Blender.Freestyle.QuantitativeInvisibilityF0D.__call__(*args) + pass class Normal2DF0D(Blender.Freestyle.Normal2DF0D): - def __call__(*args): return Blender.Freestyle.Normal2DF0D.__call__(*args) + pass class VertexOrientation2DF0D(Blender.Freestyle.VertexOrientation2DF0D): - def __call__(*args): return Blender.Freestyle.VertexOrientation2DF0D.__call__(*args) + pass class VertexOrientation3DF0D(Blender.Freestyle.VertexOrientation3DF0D): - def __call__(*args): return Blender.Freestyle.VertexOrientation3DF0D.__call__(*args) + pass class GetOccludersF0D(Blender.Freestyle.GetOccludersF0D): - def __call__(*args): return Blender.Freestyle.GetOccludersF0D.__call__(*args) + pass class GetOccludeeF0D(Blender.Freestyle.GetOccludeeF0D): - def __call__(*args): return Blender.Freestyle.GetOccludeeF0D.__call__(*args) + pass class GetShapeF0D(Blender.Freestyle.GetShapeF0D): - def __call__(*args): return Blender.Freestyle.GetShapeF0D.__call__(*args) + pass class Curvature2DAngleF1D(Blender.Freestyle.Curvature2DAngleF1D): - def __call__(*args): return Blender.Freestyle.Curvature2DAngleF1D.__call__(*args) + pass class DensityF1D(Blender.Freestyle.DensityF1D): - def __call__(*args): return Blender.Freestyle.DensityF1D.__call__(*args) + pass class GetCompleteViewMapDensityF1D(Blender.Freestyle.GetCompleteViewMapDensityF1D): - def __call__(*args): return Blender.Freestyle.GetCompleteViewMapDensityF1D.__call__(*args) + pass class GetDirectionalViewMapDensityF1D(Blender.Freestyle.GetDirectionalViewMapDensityF1D): - def __call__(*args): return Blender.Freestyle.GetDirectionalViewMapDensityF1D.__call__(*args) + pass class GetProjectedXF1D(Blender.Freestyle.GetProjectedXF1D): - def __call__(*args): return Blender.Freestyle.GetProjectedXF1D.__call__(*args) + pass class GetProjectedYF1D(Blender.Freestyle.GetProjectedYF1D): - def __call__(*args): return Blender.Freestyle.GetProjectedYF1D.__call__(*args) + pass class GetProjectedZF1D(Blender.Freestyle.GetProjectedZF1D): - def __call__(*args): return Blender.Freestyle.GetProjectedZF1D.__call__(*args) + pass class GetSteerableViewMapDensityF1D(Blender.Freestyle.GetSteerableViewMapDensityF1D): - def __call__(*args): return Blender.Freestyle.GetSteerableViewMapDensityF1D.__call__(*args) + pass class GetViewMapGradientNormF1D(Blender.Freestyle.GetViewMapGradientNormF1D): - def __call__(*args): return Blender.Freestyle.GetViewMapGradientNormF1D.__call__(*args) + pass class GetXF1D(Blender.Freestyle.GetXF1D): - def __call__(*args): return Blender.Freestyle.GetXF1D.__call__(*args) + pass class GetYF1D(Blender.Freestyle.GetYF1D): - def __call__(*args): return Blender.Freestyle.GetYF1D.__call__(*args) + pass class GetZF1D(Blender.Freestyle.GetZF1D): - def __call__(*args): return Blender.Freestyle.GetZF1D.__call__(*args) + pass class LocalAverageDepthF1D(Blender.Freestyle.LocalAverageDepthF1D): - def __call__(*args): return Blender.Freestyle.LocalAverageDepthF1D.__call__(*args) + pass class ZDiscontinuityF1D(Blender.Freestyle.ZDiscontinuityF1D): - def __call__(*args): return Blender.Freestyle.ZDiscontinuityF1D.__call__(*args) + pass class CurveNatureF1D(Blender.Freestyle.CurveNatureF1D): - def __call__(*args): return Blender.Freestyle.CurveNatureF1D.__call__(*args) + pass class QuantitativeInvisibilityF1D(Blender.Freestyle.QuantitativeInvisibilityF1D): - def __call__(*args): return Blender.Freestyle.QuantitativeInvisibilityF1D.__call__(*args) + pass class Normal2DF1D(Blender.Freestyle.Normal2DF1D): - def __call__(*args): return Blender.Freestyle.Normal2DF1D.__call__(*args) + pass class Orientation2DF1D(Blender.Freestyle.Orientation2DF1D): - def __call__(*args): return Blender.Freestyle.Orientation2DF1D.__call__(*args) + pass class Orientation3DF1D(Blender.Freestyle.Orientation3DF1D): - def __call__(*args): return Blender.Freestyle.Orientation3DF1D.__call__(*args) + pass class GetOccludeeF1D(Blender.Freestyle.GetOccludeeF1D): - def __call__(*args): return Blender.Freestyle.GetOccludeeF1D.__call__(*args) + pass class GetOccludersF1D(Blender.Freestyle.GetOccludersF1D): - def __call__(*args): return Blender.Freestyle.GetOccludersF1D.__call__(*args) + pass class GetShapeF1D(Blender.Freestyle.GetShapeF1D): - def __call__(*args): return Blender.Freestyle.GetShapeF1D.__call__(*args) + pass class ChainingTimeStampF1D(Blender.Freestyle.ChainingTimeStampF1D): - def __call__(*args): return Blender.Freestyle.ChainingTimeStampF1D.__call__(*args) + pass class IncrementChainingTimeStampF1D(Blender.Freestyle.IncrementChainingTimeStampF1D): - def __call__(*args): return Blender.Freestyle.IncrementChainingTimeStampF1D.__call__(*args) + pass class TimeStampF1D(Blender.Freestyle.TimeStampF1D): - def __call__(*args): return Blender.Freestyle.TimeStampF1D.__call__(*args) + pass |