diff options
42 files changed, 758 insertions, 145 deletions
diff --git a/source/blender/freestyle/intern/python/BPy_Convert.cpp b/source/blender/freestyle/intern/python/BPy_Convert.cpp index a1c26aaf622..5f4b7098f29 100644 --- a/source/blender/freestyle/intern/python/BPy_Convert.cpp +++ b/source/blender/freestyle/intern/python/BPy_Convert.cpp @@ -92,9 +92,9 @@ PyObject * BPy_Interface1D_from_Interface1D( Interface1D& if1D ) { } -PyObject * BPy_SVertex_from_SVertex( SVertex& sv ) { +PyObject * BPy_SVertex_from_SVertex_ptr( SVertex *sv ) { PyObject *py_sv = SVertex_Type.tp_new( &SVertex_Type, 0, 0 ); - ((BPy_SVertex *) py_sv)->sv = new SVertex( sv ); + ((BPy_SVertex *) py_sv)->sv = sv; ((BPy_SVertex *) py_sv)->py_if0D.if0D = ((BPy_SVertex *) py_sv)->sv; return py_sv; @@ -119,18 +119,17 @@ PyObject * BPy_Nature_from_Nature( unsigned short n ) { return py_n; } -PyObject * BPy_Stroke_from_Stroke( Stroke& s ) { +PyObject * BPy_Stroke_from_Stroke_ptr( 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)->s = s; ((BPy_Stroke *) py_s)->py_if1D.if1D = ((BPy_Stroke *) py_s)->s; return py_s; } -PyObject * BPy_StrokeAttribute_from_StrokeAttribute( StrokeAttribute& sa ) { +PyObject * BPy_StrokeAttribute_from_StrokeAttribute_ptr( StrokeAttribute *sa ) { PyObject *py_sa = StrokeAttribute_Type.tp_new( &StrokeAttribute_Type, 0, 0 ); - ((BPy_StrokeAttribute *) py_sa)->sa = new StrokeAttribute( sa ); - + ((BPy_StrokeAttribute *) py_sa)->sa = sa; return py_sa; } @@ -145,9 +144,9 @@ PyObject * BPy_MediumType_from_MediumType( int n ) { return py_mt; } -PyObject * BPy_StrokeVertex_from_StrokeVertex( StrokeVertex& sv ) { +PyObject * BPy_StrokeVertex_from_StrokeVertex_ptr( StrokeVertex *sv ) { PyObject *py_sv = StrokeVertex_Type.tp_new( &StrokeVertex_Type, 0, 0 ); - ((BPy_StrokeVertex *) py_sv)->sv = new StrokeVertex( sv ); + ((BPy_StrokeVertex *) py_sv)->sv = sv; ((BPy_StrokeVertex *) py_sv)->py_cp.cp = ((BPy_StrokeVertex *) py_sv)->sv; ((BPy_StrokeVertex *) py_sv)->py_cp.py_if0D.if0D = ((BPy_StrokeVertex *) py_sv)->sv; @@ -169,9 +168,9 @@ PyObject * BPy_BBox_from_BBox( BBox< Vec3r > &bb ) { return py_bb; } -PyObject * BPy_ViewEdge_from_ViewEdge( ViewEdge& ve ) { +PyObject * BPy_ViewEdge_from_ViewEdge_ptr( ViewEdge* ve ) { PyObject *py_ve = ViewEdge_Type.tp_new( &ViewEdge_Type, 0, 0 ); - ((BPy_ViewEdge *) py_ve)->ve = new ViewEdge( ve ); + ((BPy_ViewEdge *) py_ve)->ve = ve; ((BPy_ViewEdge *) py_ve)->py_if1D.if1D = ((BPy_ViewEdge *) py_ve)->ve; return py_ve; @@ -219,7 +218,7 @@ PyObject * BPy_CurvePoint_from_CurvePoint( CurvePoint& cp ) { PyObject * BPy_directedViewEdge_from_directedViewEdge( ViewVertex::directedViewEdge& dve ) { PyObject *py_dve = PyList_New(2); - PyList_SetItem( py_dve, 0, BPy_ViewEdge_from_ViewEdge(*(dve.first)) ); + PyList_SetItem( py_dve, 0, BPy_ViewEdge_from_ViewEdge_ptr(dve.first) ); PyList_SetItem( py_dve, 1, PyBool_from_bool(dve.second) ); return py_dve; @@ -316,7 +315,7 @@ PyObject * BPy_ChainSilhouetteIterator_from_ChainSilhouetteIterator( ChainSilhou //============================== bool bool_from_PyBool( PyObject *b ) { - return b == Py_True; + return (b == Py_True || PyInt_AsLong(b) != 0); } IntegrationType IntegrationType_from_BPy_IntegrationType( PyObject* obj ) { diff --git a/source/blender/freestyle/intern/python/BPy_Convert.h b/source/blender/freestyle/intern/python/BPy_Convert.h index 5bfdef56278..10efb2e5246 100644 --- a/source/blender/freestyle/intern/python/BPy_Convert.h +++ b/source/blender/freestyle/intern/python/BPy_Convert.h @@ -82,12 +82,12 @@ 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 ); +PyObject * BPy_Stroke_from_Stroke_ptr( Stroke* s ); +PyObject * BPy_StrokeAttribute_from_StrokeAttribute_ptr( StrokeAttribute *sa ); +PyObject * BPy_StrokeVertex_from_StrokeVertex_ptr( StrokeVertex *sv ); +PyObject * BPy_SVertex_from_SVertex_ptr( SVertex *sv ); PyObject * BPy_ViewVertex_from_ViewVertex_ptr( ViewVertex *vv ); -PyObject * BPy_ViewEdge_from_ViewEdge( ViewEdge& ve ); +PyObject * BPy_ViewEdge_from_ViewEdge_ptr( ViewEdge *ve ); PyObject * BPy_ViewShape_from_ViewShape( ViewShape& vs ); PyObject * BPy_AdjacencyIterator_from_AdjacencyIterator( AdjacencyIterator& a_it ); diff --git a/source/blender/freestyle/intern/python/BPy_Interface0D.cpp b/source/blender/freestyle/intern/python/BPy_Interface0D.cpp index 506fc3b4e9d..78bd4176658 100644 --- a/source/blender/freestyle/intern/python/BPy_Interface0D.cpp +++ b/source/blender/freestyle/intern/python/BPy_Interface0D.cpp @@ -183,12 +183,14 @@ PyMODINIT_FUNC Interface0D_Init( PyObject *module ) int Interface0D___init__(BPy_Interface0D *self, PyObject *args, PyObject *kwds) { self->if0D = new Interface0D(); + self->if0D->py_if0D = (PyObject *)self; return 0; } void Interface0D___dealloc__(BPy_Interface0D* self) { - delete self->if0D; + if( self->if0D->py_if0D ) + delete self->if0D; self->ob_type->tp_free((PyObject*)self); } diff --git a/source/blender/freestyle/intern/python/BPy_Interface1D.cpp b/source/blender/freestyle/intern/python/BPy_Interface1D.cpp index 8d2549ebf2c..cfa9c3066a1 100644 --- a/source/blender/freestyle/intern/python/BPy_Interface1D.cpp +++ b/source/blender/freestyle/intern/python/BPy_Interface1D.cpp @@ -204,7 +204,8 @@ int Interface1D___init__(BPy_Interface1D *self, PyObject *args, PyObject *kwds) void Interface1D___dealloc__(BPy_Interface1D* self) { - delete self->if1D; + if( self->if1D->py_if1D ) + delete self->if1D; self->ob_type->tp_free((PyObject*)self); } diff --git a/source/blender/freestyle/intern/python/BPy_Iterator.cpp b/source/blender/freestyle/intern/python/BPy_Iterator.cpp index 23dd68e0aa8..5c19dfd29ac 100644 --- a/source/blender/freestyle/intern/python/BPy_Iterator.cpp +++ b/source/blender/freestyle/intern/python/BPy_Iterator.cpp @@ -227,10 +227,6 @@ PyObject * Iterator_isEnd(BPy_Iterator* self) { return PyBool_from_bool( self->it->isEnd() ); } -PyObject * Iterator_getObject(BPy_Iterator* self) { - return PyBool_from_bool( self->it->isEnd() ); -} - /////////////////////////////////////////////////////////////////////////////////////////// diff --git a/source/blender/freestyle/intern/python/BPy_Operators.cpp b/source/blender/freestyle/intern/python/BPy_Operators.cpp index ab64f5bc6eb..c1b0b59daae 100644 --- a/source/blender/freestyle/intern/python/BPy_Operators.cpp +++ b/source/blender/freestyle/intern/python/BPy_Operators.cpp @@ -24,28 +24,27 @@ static PyObject * Operators_sequentialSplit(BPy_Operators* self, PyObject *args) static PyObject * Operators_recursiveSplit(BPy_Operators* self, PyObject *args); static PyObject * Operators_sort(BPy_Operators* self, PyObject *args); static PyObject * Operators_create(BPy_Operators* self, PyObject *args); +static PyObject * Operators_getViewEdgesSize( BPy_Operators* self); +static PyObject * Operators_getChainsSize( BPy_Operators* self); +static PyObject * Operators_getStrokesSize( BPy_Operators* self); /*----------------------Operators instance definitions ----------------------------*/ static PyMethodDef BPy_Operators_methods[] = { {"select", ( PyCFunction ) Operators_select, METH_VARARGS | METH_STATIC, "select operator"}, - {"bidirectionalChain", ( PyCFunction ) Operators_bidirectionalChain, METH_VARARGS | METH_STATIC, - "select operator"}, - + "bidirectionalChain operator"}, {"sequentialSplit", ( PyCFunction ) Operators_sequentialSplit, METH_VARARGS | METH_STATIC, - "select operator"}, - + "sequentialSplit operator"}, {"recursiveSplit", ( PyCFunction ) Operators_recursiveSplit, METH_VARARGS | METH_STATIC, - "select operator"}, - + "recursiveSplit operator"}, {"sort", ( PyCFunction ) Operators_sort, METH_VARARGS | METH_STATIC, - "select operator"}, - + "sort operator"}, {"create", ( PyCFunction ) Operators_create, METH_VARARGS | METH_STATIC, - "select operator"}, - - + "create operator"}, + {"getViewEdgesSize", ( PyCFunction ) Operators_getViewEdgesSize, METH_NOARGS | METH_STATIC, ""}, + {"getChainsSize", ( PyCFunction ) Operators_getChainsSize, METH_NOARGS | METH_STATIC, ""}, + {"getStrokesSize", ( PyCFunction ) Operators_getStrokesSize, METH_NOARGS | METH_STATIC, ""}, {NULL, NULL, 0, NULL} }; @@ -322,6 +321,19 @@ PyObject * Operators_create(BPy_Operators* self, PyObject *args) Py_RETURN_NONE; } +PyObject * Operators_getViewEdgesSize( BPy_Operators* self) { + return PyInt_FromLong( Operators::getViewEdgesSize() ); +} + +PyObject * Operators_getChainsSize( BPy_Operators* self ) { + return PyInt_FromLong( Operators::getChainsSize() ); +} + +PyObject * Operators_getStrokesSize( BPy_Operators* self) { + return PyInt_FromLong( Operators::getStrokesSize() ); +} + + /////////////////////////////////////////////////////////////////////////////////////////// #ifdef __cplusplus diff --git a/source/blender/freestyle/intern/python/BPy_SShape.cpp b/source/blender/freestyle/intern/python/BPy_SShape.cpp index ab8a39d6193..529090d5815 100644 --- a/source/blender/freestyle/intern/python/BPy_SShape.cpp +++ b/source/blender/freestyle/intern/python/BPy_SShape.cpp @@ -228,7 +228,7 @@ PyObject * SShape_getVertexList( BPy_SShape *self ) { vector< SVertex * >::iterator it; for( it = vertices.begin(); it != vertices.end(); it++ ) { - PyList_Append( py_vertices, BPy_SVertex_from_SVertex(*( *it )) ); + PyList_Append( py_vertices, BPy_SVertex_from_SVertex_ptr(*it) ); } return py_vertices; diff --git a/source/blender/freestyle/intern/python/BPy_StrokeAttribute.cpp b/source/blender/freestyle/intern/python/BPy_StrokeAttribute.cpp index 541ef4f4516..cc4c8288233 100644 --- a/source/blender/freestyle/intern/python/BPy_StrokeAttribute.cpp +++ b/source/blender/freestyle/intern/python/BPy_StrokeAttribute.cpp @@ -199,6 +199,7 @@ int StrokeAttribute___init__(BPy_StrokeAttribute *self, PyObject *args, PyObject return -1; } + self->sa->py_sa = (PyObject *) self; return 0; @@ -206,7 +207,8 @@ int StrokeAttribute___init__(BPy_StrokeAttribute *self, PyObject *args, PyObject void StrokeAttribute___dealloc__(BPy_StrokeAttribute* self) { - delete self->sa; + if( self->sa->py_sa ) + delete self->sa; self->ob_type->tp_free((PyObject*)self); } @@ -384,7 +386,7 @@ PyObject * StrokeAttribute_setThickness( BPy_StrokeAttribute *self, PyObject *ar PyFloat_AsDouble( PyList_GetItem(obj1, 1) ) ); self->sa->setThickness( v ); - + } else if( obj1 && obj2 ){ self->sa->setThickness( PyFloat_AsDouble(obj1), diff --git a/source/blender/freestyle/intern/python/BPy_StrokeShader.cpp b/source/blender/freestyle/intern/python/BPy_StrokeShader.cpp index 3b756b40d9b..6560bda3167 100644 --- a/source/blender/freestyle/intern/python/BPy_StrokeShader.cpp +++ b/source/blender/freestyle/intern/python/BPy_StrokeShader.cpp @@ -17,6 +17,7 @@ #include "StrokeShader/BPy_IncreasingThicknessShader.h" #include "StrokeShader/BPy_PolygonalizationShader.h" #include "StrokeShader/BPy_SamplingShader.h" +#include "StrokeShader/BPy_SmoothingShader.h" #include "StrokeShader/BPy_SpatialNoiseShader.h" #include "StrokeShader/BPy_streamShader.h" #include "StrokeShader/BPy_StrokeTextureShader.h" @@ -212,6 +213,11 @@ PyMODINIT_FUNC StrokeShader_Init( PyObject *module ) Py_INCREF( &SamplingShader_Type ); PyModule_AddObject(module, "SamplingShader", (PyObject *)&SamplingShader_Type); + if( PyType_Ready( &SmoothingShader_Type ) < 0 ) + return; + Py_INCREF( &SmoothingShader_Type ); + PyModule_AddObject(module, "SmoothingShader", (PyObject *)&SmoothingShader_Type); + if( PyType_Ready( &SpatialNoiseShader_Type ) < 0 ) return; Py_INCREF( &SpatialNoiseShader_Type ); diff --git a/source/blender/freestyle/intern/python/BPy_UnaryPredicate0D.cpp b/source/blender/freestyle/intern/python/BPy_UnaryPredicate0D.cpp index db708c7830b..f751d092920 100644 --- a/source/blender/freestyle/intern/python/BPy_UnaryPredicate0D.cpp +++ b/source/blender/freestyle/intern/python/BPy_UnaryPredicate0D.cpp @@ -174,6 +174,8 @@ PyObject * UnaryPredicate0D___call__( BPy_UnaryPredicate0D *self, PyObject *args if( if0D_it ) return PyBool_from_bool( self->up0D->operator()(*if0D_it) ); + else + cerr << "ERROR: UnaryPredicate0D___call__ (no Interface0DIterator)" << endl; Py_RETURN_NONE; } diff --git a/source/blender/freestyle/intern/python/BPy_UnaryPredicate1D.cpp b/source/blender/freestyle/intern/python/BPy_UnaryPredicate1D.cpp index f2b2c7b9b53..0ae76b5eae6 100644 --- a/source/blender/freestyle/intern/python/BPy_UnaryPredicate1D.cpp +++ b/source/blender/freestyle/intern/python/BPy_UnaryPredicate1D.cpp @@ -216,6 +216,8 @@ PyObject * UnaryPredicate1D___call__( BPy_UnaryPredicate1D *self, PyObject *args if( if1D ) return PyBool_from_bool( self->up1D->operator()(*if1D) ); + else + cerr << "ERROR: UnaryPredicate1D___call__ (no Interface1D)" << endl; Py_RETURN_NONE; } diff --git a/source/blender/freestyle/intern/python/BPy_ViewMap.cpp b/source/blender/freestyle/intern/python/BPy_ViewMap.cpp index e8633770c8c..c010236964a 100644 --- a/source/blender/freestyle/intern/python/BPy_ViewMap.cpp +++ b/source/blender/freestyle/intern/python/BPy_ViewMap.cpp @@ -157,7 +157,7 @@ PyObject * ViewMap_getClosestViewEdge( BPy_ViewMap *self , PyObject *args) { ViewEdge *ve = const_cast<ViewEdge *>( self->vm->getClosestViewEdge(x,y) ); if( ve ) - return BPy_ViewEdge_from_ViewEdge(*ve); + return BPy_ViewEdge_from_ViewEdge_ptr(ve); Py_RETURN_NONE; } diff --git a/source/blender/freestyle/intern/python/BPy_ViewShape.cpp b/source/blender/freestyle/intern/python/BPy_ViewShape.cpp index a87859491b4..fd676c54c7b 100644 --- a/source/blender/freestyle/intern/python/BPy_ViewShape.cpp +++ b/source/blender/freestyle/intern/python/BPy_ViewShape.cpp @@ -198,7 +198,7 @@ PyObject * ViewShape_edges( BPy_ViewShape *self ) { vector< ViewEdge * >::iterator it; for( it = edges.begin(); it != edges.end(); it++ ) { - PyList_Append( py_edges, BPy_ViewEdge_from_ViewEdge(*( *it )) ); + PyList_Append( py_edges, BPy_ViewEdge_from_ViewEdge_ptr(*it) ); } return py_edges; diff --git a/source/blender/freestyle/intern/python/Director.cpp b/source/blender/freestyle/intern/python/Director.cpp index b3188554c09..153ea79eabf 100644 --- a/source/blender/freestyle/intern/python/Director.cpp +++ b/source/blender/freestyle/intern/python/Director.cpp @@ -13,6 +13,11 @@ #include "BPy_StrokeShader.h" #include "Iterator/BPy_ChainingIterator.h" #include "Iterator/BPy_Interface0DIterator.h" +#include "Interface0D/BPy_SVertex.h" +#include "Interface0D/BPy_ViewVertex.h" +#include "Interface0D/ViewVertex/BPy_NonTVertex.h" +#include "Interface0D/ViewVertex/BPy_TVertex.h" +#include "Interface1D/BPy_FEdge.h" #include "Interface1D/BPy_Stroke.h" #include "Interface1D/BPy_ViewEdge.h" #include "BPy_ViewShape.h" @@ -28,6 +33,15 @@ #include "UnaryFunction0D/BPy_UnaryFunction0DVectorViewShape.h" #include "UnaryFunction0D/BPy_UnaryFunction0DViewShape.h" +#include "UnaryFunction1D/BPy_UnaryFunction1DDouble.h" +#include "UnaryFunction1D/BPy_UnaryFunction1DEdgeNature.h" +#include "UnaryFunction1D/BPy_UnaryFunction1DFloat.h" +#include "UnaryFunction1D/BPy_UnaryFunction1DUnsigned.h" +#include "UnaryFunction1D/BPy_UnaryFunction1DVec2f.h" +#include "UnaryFunction1D/BPy_UnaryFunction1DVec3f.h" +#include "UnaryFunction1D/BPy_UnaryFunction1DVectorViewShape.h" + + // 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) ); @@ -62,7 +76,7 @@ bool Director_BPy_UnaryPredicate1D___call__( PyObject *obj, Interface1D& if1D) { // StrokeShader: shade void Director_BPy_StrokeShader_shade( PyObject *obj, Stroke& s) { - PyObject_CallMethod( obj, "shade", "O", BPy_Stroke_from_Stroke(s) ); + PyObject_CallMethod( obj, "shade", "O", BPy_Stroke_from_Stroke_ptr(&s) ); } // ChainingIterator: init, traverse @@ -89,7 +103,6 @@ void Director_BPy_UnaryFunction0D___call__( void *uf0D, PyObject *obj, Interface ((UnaryFunction0D<Nature::EdgeNature> *) uf0D)->result = EdgeNature_from_BPy_Nature(result); } else if ( BPy_UnaryFunction0DFloat_Check(obj) ) { - ((UnaryFunction0D<float> *) uf0D)->result = PyFloat_AsDouble(result); } else if ( BPy_UnaryFunction0DId_Check(obj) ) { @@ -129,20 +142,45 @@ void Director_BPy_UnaryFunction0D___call__( void *uf0D, PyObject *obj, Interface void Director_BPy_UnaryFunction1D___call__( void *uf1D, PyObject *obj, Interface1D& if1D) { -// BPy_UnaryFunction1DDouble -// BPy_UnaryFunction1DEdgeNature -// BPy_UnaryFunction1DFloat -// BPy_UnaryFunction1DUnsigned -// BPy_UnaryFunction1DVec2f -// BPy_UnaryFunction1DVec3f -// BPy_UnaryFunction1DVectorViewShape -// BPy_UnaryFunction1DVoid + PyObject *result = PyObject_CallMethod( obj, "__call__", "O", BPy_Interface1D_from_Interface1D(if1D) ); + + if( BPy_UnaryFunction1DDouble_Check(obj) ) { + ((UnaryFunction1D<double> *) uf1D)->result = PyFloat_AsDouble(result); + } else if ( BPy_UnaryFunction1DEdgeNature_Check(obj) ) { + ((UnaryFunction1D<Nature::EdgeNature> *) uf1D)->result = EdgeNature_from_BPy_Nature(result); + + } else if ( BPy_UnaryFunction1DFloat_Check(obj) ) { + ((UnaryFunction1D<float> *) uf1D)->result = PyFloat_AsDouble(result); + + } else if ( BPy_UnaryFunction1DUnsigned_Check(obj) ) { + ((UnaryFunction1D<unsigned> *) uf1D)->result = PyInt_AsLong(result); + + } else if ( BPy_UnaryFunction1DVec2f_Check(obj) ) { + Vec2f *v = Vec2f_ptr_from_Vector( result ); + ((UnaryFunction1D<Vec2f> *) uf1D)->result = *v; + delete v; + + } else if ( BPy_UnaryFunction1DVec3f_Check(obj) ) { + Vec3f *v = Vec3f_ptr_from_Vector( result ); + ((UnaryFunction1D<Vec3f> *) uf1D)->result = *v; + delete v; + + } else if ( BPy_UnaryFunction1DVectorViewShape_Check(obj) ) { + vector<ViewShape*> vec; + for( int i = 1; i < PyList_Size(result); i++) { + ViewShape *b = ( (BPy_ViewShape *) PyList_GetItem(result, i) )->vs; + vec.push_back( b ); + } + + ((UnaryFunction1D< vector<ViewShape*> > *) uf1D)->result = vec; + + } } -// BPy_Iterator: increment, decrement, isBegin, isEnd +// Iterator: increment, decrement, isBegin, isEnd void Director_BPy_Iterator_increment( PyObject *obj ) { PyObject_CallMethod( obj, "increment", "", 0 ); } @@ -163,7 +201,106 @@ bool Director_BPy_Iterator_isEnd( PyObject *obj ) { return bool_from_PyBool(result); } -// BPy_Interface1D: verticesBegin, verticesEnd, pointsBegin, pointsEnd +// Interface0D: getX, getY, getZ, getPoint3D, getProjectedX, getProjectedY, getProjectedZ, getPoint2D, getFEdge, getId, getNature, castToSVertex, castToViewVertex, castToNonTVertex, castToTVertex +double Director_BPy_Interface0D_getX( PyObject *obj ) { + PyObject *result = PyObject_CallMethod( obj, "getX", "", 0 ); + + return PyFloat_AsDouble(result); +} + +double Director_BPy_Interface0D_getY( PyObject *obj ) { + PyObject *result = PyObject_CallMethod( obj, "getY", "", 0 ); + + return PyFloat_AsDouble(result); +} + +double Director_BPy_Interface0D_getZ( PyObject *obj ) { + PyObject *result = PyObject_CallMethod( obj, "getZ", "", 0 ); + + return PyFloat_AsDouble(result); +} + +Geometry::Vec3f Director_BPy_Interface0D_getPoint3D( PyObject *obj ) { + PyObject *result = PyObject_CallMethod( obj, "getPoint3D", "", 0 ); + + Geometry::Vec3f *v_ref = Vec3f_ptr_from_Vector( result ); + Geometry::Vec3f v(*v_ref); + delete v_ref; + + return v; +} + +double Director_BPy_Interface0D_getProjectedX( PyObject *obj ) { + PyObject *result = PyObject_CallMethod( obj, "getProjectedX", "", 0 ); + + return PyFloat_AsDouble(result); +} + +double Director_BPy_Interface0D_getProjectedY( PyObject *obj ) { + PyObject *result = PyObject_CallMethod( obj, "getProjectedY", "", 0 ); + + return PyFloat_AsDouble(result); +} + +double Director_BPy_Interface0D_getProjectedZ( PyObject *obj ) { + PyObject *result = PyObject_CallMethod( obj, "getProjectedZ", "", 0 ); + + return PyFloat_AsDouble(result); +} + +Geometry::Vec2f Director_BPy_Interface0D_getPoint2D( PyObject *obj ) { + PyObject *result = PyObject_CallMethod( obj, "getPoint2D", "", 0 ); + + Geometry::Vec2f *v_ref = Vec2f_ptr_from_Vector( result ); + Geometry::Vec2f v(*v_ref); + delete v_ref; + + return v; +} + +FEdge * Director_BPy_Interface0D_getFEdge( PyObject *obj ) { + PyObject *result = PyObject_CallMethod( obj, "getFEdge", "", 0 ); + + return ((BPy_FEdge *) result)->fe; +} + +Id Director_BPy_Interface0D_getId( PyObject *obj ) { + PyObject *result = PyObject_CallMethod( obj, "getId", "", 0 ); + + return *( ((BPy_Id *) result)->id ); +} + +Nature::EdgeNature Director_BPy_Interface0D_getNature( PyObject *obj ) { + PyObject *result = PyObject_CallMethod( obj, "getNature", "", 0 ); + + return EdgeNature_from_BPy_Nature(result); +} + +SVertex * Director_BPy_Interface0D_castToSVertex( PyObject *obj ) { + PyObject *result = PyObject_CallMethod( obj, "castToSVertex", "", 0 ); + + return ((BPy_SVertex *) result)->sv; +} + +ViewVertex * Director_BPy_Interface0D_castToViewVertex( PyObject *obj ) { + PyObject *result = PyObject_CallMethod( obj, "castToViewVertex", "", 0 ); + + return ((BPy_ViewVertex *) result)->vv; +} + +NonTVertex * Director_BPy_Interface0D_castToNonTVertex( PyObject *obj ) { + PyObject *result = PyObject_CallMethod( obj, "castToNonTVertex", "", 0 ); + + return ((BPy_NonTVertex *) result)->ntv; +} + +TVertex * Director_BPy_Interface0D_castToTVertex( PyObject *obj ) { + PyObject *result = PyObject_CallMethod( obj, "castToTVertex", "", 0 ); + + return ((BPy_TVertex *) result)->tv; +} + +// Interface1D: verticesBegin, verticesEnd, pointsBegin, pointsEnd Interface0DIterator Director_BPy_Interface1D_verticesBegin( PyObject *obj ){ PyObject *result = PyObject_CallMethod( obj, "verticesBegin", "", 0 ); @@ -188,3 +325,20 @@ Interface0DIterator Director_BPy_Interface1D_pointsEnd( PyObject *obj ){ return *( ((BPy_Interface0DIterator *) result)->if0D_it ); } +double Director_BPy_Interface1D_getLength2D( PyObject *obj ) { + PyObject *result = PyObject_CallMethod( obj, "getLength2D", "", 0 ); + + return PyFloat_AsDouble(result); +} + +Id Director_BPy_Interface1D_getId( PyObject *obj ) { + PyObject *result = PyObject_CallMethod( obj, "getId", "", 0 ); + + return *( ((BPy_Id *) result)->id ); +} + +Nature::EdgeNature Director_BPy_Interface1D_getNature( PyObject *obj ) { + PyObject *result = PyObject_CallMethod( obj, "getNature", "", 0 ); + + return EdgeNature_from_BPy_Nature( result ); +}
\ No newline at end of file diff --git a/source/blender/freestyle/intern/python/Director.h b/source/blender/freestyle/intern/python/Director.h index 27afa3bbe3e..22bf80c5c14 100644 --- a/source/blender/freestyle/intern/python/Director.h +++ b/source/blender/freestyle/intern/python/Director.h @@ -1,12 +1,22 @@ #ifndef FREESTYLE_PYTHON_DIRECTOR # define FREESTYLE_PYTHON_DIRECTOR +#include "../geometry/Geom.h" +#include "../winged_edge/Nature.h" + +class AdjacencyIterator; +class FEdge; +class Id; class Interface0D; class Interface1D; class Interface0DIterator; +class NonTVertex; class Stroke; -class AdjacencyIterator; +class SVertex; +class TVertex; class ViewEdge; +class ViewVertex; + #ifdef __cplusplus extern "C" { @@ -24,6 +34,36 @@ bool Director_BPy_BinaryPredicate0D___call__( PyObject *obj, Interface0D& i1, In // BinaryPredicate1D: __call__ bool Director_BPy_BinaryPredicate1D___call__( PyObject *obj, Interface1D& i1, Interface1D& i2); +// Interface0D: getX, getY, getZ, getPoint3D, getProjectedX, getProjectedY, getProjectedZ, getPoint2D, getFEdge, getId, getNature, castToSVertex, castToViewVertex, castToNonTVertex, castToTVertex +double Director_BPy_Interface0D_getX( PyObject *obj ); +double Director_BPy_Interface0D_getY( PyObject *obj ); +double Director_BPy_Interface0D_getZ( PyObject *obj ); +Geometry::Vec3f Director_BPy_Interface0D_getPoint3D( PyObject *obj ); +double Director_BPy_Interface0D_getProjectedX( PyObject *obj ); +double Director_BPy_Interface0D_getProjectedY( PyObject *obj ); +double Director_BPy_Interface0D_getProjectedZ( PyObject *obj ); +Geometry::Vec2f Director_BPy_Interface0D_getPoint2D( PyObject *obj ); +FEdge * Director_BPy_Interface0D_getFEdge( PyObject *obj ); +Id Director_BPy_Interface0D_getId( PyObject *obj ); +Nature::EdgeNature Director_BPy_Interface0D_getNature( PyObject *obj ); +SVertex * Director_BPy_Interface0D_castToSVertex( PyObject *obj ); +ViewVertex * Director_BPy_Interface0D_castToViewVertex( PyObject *obj ); +NonTVertex * Director_BPy_Interface0D_castToNonTVertex( PyObject *obj ); +TVertex * Director_BPy_Interface0D_castToTVertex( PyObject *obj ); + +// Interface1D: verticesBegin, verticesEnd, pointsBegin, pointsEnd, getLength2D, getId, getNature +Interface0DIterator Director_BPy_Interface1D_verticesBegin( PyObject *obj ); +Interface0DIterator Director_BPy_Interface1D_verticesEnd( PyObject *obj ); +Interface0DIterator Director_BPy_Interface1D_pointsBegin( PyObject *obj ); +Interface0DIterator Director_BPy_Interface1D_pointsEnd( PyObject *obj ); +double Director_BPy_Interface1D_getLength2D( PyObject *obj ); +Id Director_BPy_Interface1D_getId( PyObject *obj ); +Nature::EdgeNature Director_BPy_Interface1D_getNature( PyObject *obj ); + +// UnaryFunction{0D,1D}: __call__ +void Director_BPy_UnaryFunction0D___call__( void *uf0D, PyObject *obj, Interface0DIterator& if0D_it); +void Director_BPy_UnaryFunction1D___call__( void *uf1D, PyObject *obj, Interface1D& if1D); + // UnaryPredicate0D: __call__ bool Director_BPy_UnaryPredicate0D___call__( PyObject *obj, Interface0DIterator& if0D_it); @@ -33,25 +73,17 @@ 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_UnaryFunction{0D,1D}: __call__ -void Director_BPy_UnaryFunction0D___call__( void *uf0D, PyObject *obj, Interface0DIterator& if0D_it); -void Director_BPy_UnaryFunction1D___call__( void *uf1D, PyObject *obj, Interface1D& if1D); - -// BPy_Iterator: increment, decrement, isBegin, isEnd +// Iterator: increment, decrement, isBegin, isEnd void Director_BPy_Iterator_increment( PyObject *obj ); void Director_BPy_Iterator_decrement( PyObject *obj ); bool Director_BPy_Iterator_isBegin( PyObject *obj ); bool Director_BPy_Iterator_isEnd( PyObject *obj ); -// BPy_Interface1D: verticesBegin, verticesEnd, pointsBegin, pointsEnd -Interface0DIterator Director_BPy_Interface1D_verticesBegin( PyObject *obj ); -Interface0DIterator Director_BPy_Interface1D_verticesEnd( PyObject *obj ); -Interface0DIterator Director_BPy_Interface1D_pointsBegin( PyObject *obj ); -Interface0DIterator Director_BPy_Interface1D_pointsEnd( PyObject *obj ); +// ChainingIterator: init, traverse +void Director_BPy_ChainingIterator_init( PyObject *obj ); +ViewEdge * Director_BPy_ChainingIterator_traverse( PyObject *obj, AdjacencyIterator& a_it ); + + diff --git a/source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.cpp b/source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.cpp index 7fce126d309..cb2e30f841a 100644 --- a/source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.cpp +++ b/source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.cpp @@ -167,14 +167,14 @@ PyObject * CurvePoint___copy__( BPy_CurvePoint *self ) { PyObject * CurvePoint_A( BPy_CurvePoint *self ) { if( SVertex *A = self->cp->A() ) - return BPy_SVertex_from_SVertex( *A ); + return BPy_SVertex_from_SVertex_ptr( A ); Py_RETURN_NONE; } PyObject * CurvePoint_B( BPy_CurvePoint *self ) { if( SVertex *B = self->cp->B() ) - return BPy_SVertex_from_SVertex( *B ); + return BPy_SVertex_from_SVertex_ptr( B ); Py_RETURN_NONE; } diff --git a/source/blender/freestyle/intern/python/Interface0D/CurvePoint/BPy_StrokeVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/CurvePoint/BPy_StrokeVertex.cpp index 3616e69447f..1e2d34c2767 100644 --- a/source/blender/freestyle/intern/python/Interface0D/CurvePoint/BPy_StrokeVertex.cpp +++ b/source/blender/freestyle/intern/python/Interface0D/CurvePoint/BPy_StrokeVertex.cpp @@ -183,8 +183,7 @@ PyObject * StrokeVertex_getPoint( BPy_StrokeVertex *self ) { } PyObject * StrokeVertex_attribute( BPy_StrokeVertex *self ) { - StrokeAttribute sa( self->sv->attribute() ); - return BPy_StrokeAttribute_from_StrokeAttribute( sa ); + return BPy_StrokeAttribute_from_StrokeAttribute_ptr( &(self->sv->attribute()) ); } PyObject * StrokeVertex_curvilinearAbscissa( BPy_StrokeVertex *self ) { diff --git a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.cpp index 206674a20a5..74c91856bbd 100644 --- a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.cpp +++ b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.cpp @@ -165,7 +165,7 @@ PyObject * NonTVertex_castToNonTVertex( BPy_NonTVertex *self ) { PyObject * NonTVertex_svertex( BPy_NonTVertex *self ) { if( self->ntv->svertex() ){ - return BPy_SVertex_from_SVertex(*( self->ntv->svertex() )); + return BPy_SVertex_from_SVertex_ptr( self->ntv->svertex() ); } Py_RETURN_NONE; diff --git a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp index ab8bb72604c..83ec27818fa 100644 --- a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp +++ b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp @@ -155,7 +155,7 @@ PyObject * TVertex_castToTVertex( BPy_TVertex *self ) { PyObject * TVertex_frontSVertex( BPy_TVertex *self ) { if( self->tv->frontSVertex() ){ - return BPy_SVertex_from_SVertex(*( self->tv->frontSVertex() )); + return BPy_SVertex_from_SVertex_ptr( self->tv->frontSVertex() ); } Py_RETURN_NONE; @@ -163,7 +163,7 @@ PyObject * TVertex_frontSVertex( BPy_TVertex *self ) { PyObject * TVertex_backSVertex( BPy_TVertex *self ) { if( self->tv->backSVertex() ){ - return BPy_SVertex_from_SVertex(*( self->tv->backSVertex() )); + return BPy_SVertex_from_SVertex_ptr( self->tv->backSVertex() ); } Py_RETURN_NONE; @@ -219,7 +219,7 @@ PyObject * TVertex_getSVertex( BPy_TVertex *self, PyObject *args) { SVertex *sv = self->tv->getSVertex( ((BPy_FEdge *) py_fe)->fe ); if( sv ){ - return BPy_SVertex_from_SVertex(*( sv )); + return BPy_SVertex_from_SVertex_ptr( sv ); } Py_RETURN_NONE; @@ -235,7 +235,7 @@ PyObject * TVertex_mate( BPy_TVertex *self, PyObject *args) { ViewEdge *ve = self->tv->mate( ((BPy_ViewEdge *) py_ve)->ve ); if( ve ){ - return BPy_ViewEdge_from_ViewEdge(*( ve )); + return BPy_ViewEdge_from_ViewEdge_ptr( ve ); } Py_RETURN_NONE; diff --git a/source/blender/freestyle/intern/python/Interface1D/BPy_FEdge.cpp b/source/blender/freestyle/intern/python/Interface1D/BPy_FEdge.cpp index 369dd7c61a5..0718c18b253 100644 --- a/source/blender/freestyle/intern/python/Interface1D/BPy_FEdge.cpp +++ b/source/blender/freestyle/intern/python/Interface1D/BPy_FEdge.cpp @@ -185,7 +185,7 @@ PyObject * FEdge___copy__( BPy_FEdge *self ) { PyObject * FEdge_vertexA( BPy_FEdge *self ) { if( self->fe->vertexA() ){ - return BPy_SVertex_from_SVertex( *(self->fe->vertexA()) ); + return BPy_SVertex_from_SVertex_ptr( self->fe->vertexA() ); } Py_RETURN_NONE; @@ -193,7 +193,7 @@ PyObject * FEdge_vertexA( BPy_FEdge *self ) { PyObject * FEdge_vertexB( BPy_FEdge *self ) { if( self->fe->vertexB() ){ - return BPy_SVertex_from_SVertex( *(self->fe->vertexB()) ); + return BPy_SVertex_from_SVertex_ptr( self->fe->vertexB() ); } Py_RETURN_NONE; @@ -209,7 +209,7 @@ PyObject * FEdge___getitem__( BPy_FEdge *self, PyObject *args ) { } if( SVertex *v = self->fe->operator[](i) ) - return BPy_SVertex_from_SVertex( *v ); + return BPy_SVertex_from_SVertex_ptr( v ); Py_RETURN_NONE; } @@ -230,7 +230,7 @@ PyObject * FEdge_previousEdge( BPy_FEdge *self ) { PyObject * FEdge_viewedge( BPy_FEdge *self ) { if( ViewEdge *ve = self->fe->viewedge() ) - return BPy_ViewEdge_from_ViewEdge( *ve ); + return BPy_ViewEdge_from_ViewEdge_ptr( ve ); Py_RETURN_NONE; } diff --git a/source/blender/freestyle/intern/python/Iterator/BPy_AdjacencyIterator.cpp b/source/blender/freestyle/intern/python/Iterator/BPy_AdjacencyIterator.cpp index 139db9dd73f..9b92ac4a3a0 100644 --- a/source/blender/freestyle/intern/python/Iterator/BPy_AdjacencyIterator.cpp +++ b/source/blender/freestyle/intern/python/Iterator/BPy_AdjacencyIterator.cpp @@ -143,7 +143,7 @@ PyObject * AdjacencyIterator_getObject(BPy_AdjacencyIterator *self) { ViewEdge *ve = self->a_it->operator*(); if( ve ) - return BPy_ViewEdge_from_ViewEdge( *ve ); + return BPy_ViewEdge_from_ViewEdge_ptr( ve ); Py_RETURN_NONE; } diff --git a/source/blender/freestyle/intern/python/Iterator/BPy_ChainingIterator.cpp b/source/blender/freestyle/intern/python/Iterator/BPy_ChainingIterator.cpp index f33fe0e17bc..05822f4c6fe 100644 --- a/source/blender/freestyle/intern/python/Iterator/BPy_ChainingIterator.cpp +++ b/source/blender/freestyle/intern/python/Iterator/BPy_ChainingIterator.cpp @@ -180,7 +180,7 @@ PyObject * ChainingIterator_getObject( BPy_ChainingIterator *self) { ViewEdge *ve = self->c_it->operator*(); if( ve ) - return BPy_ViewEdge_from_ViewEdge( *ve ); + return BPy_ViewEdge_from_ViewEdge_ptr( ve ); Py_RETURN_NONE; } diff --git a/source/blender/freestyle/intern/python/Iterator/BPy_SVertexIterator.cpp b/source/blender/freestyle/intern/python/Iterator/BPy_SVertexIterator.cpp index 383480b8a9d..c10d3406909 100644 --- a/source/blender/freestyle/intern/python/Iterator/BPy_SVertexIterator.cpp +++ b/source/blender/freestyle/intern/python/Iterator/BPy_SVertexIterator.cpp @@ -160,7 +160,12 @@ PyObject * SVertexIterator_u( BPy_SVertexIterator *self ) { } PyObject * SVertexIterator_getObject( BPy_SVertexIterator *self) { - return BPy_SVertex_from_SVertex( self->sv_it->operator*() ); + SVertex *sv = self->sv_it->operator->(); + + if( sv ) + return BPy_SVertex_from_SVertex_ptr( sv ); + + Py_RETURN_NONE; } diff --git a/source/blender/freestyle/intern/python/Iterator/BPy_StrokeVertexIterator.cpp b/source/blender/freestyle/intern/python/Iterator/BPy_StrokeVertexIterator.cpp index 0b1554a1cb7..1994cb9ce6d 100644 --- a/source/blender/freestyle/intern/python/Iterator/BPy_StrokeVertexIterator.cpp +++ b/source/blender/freestyle/intern/python/Iterator/BPy_StrokeVertexIterator.cpp @@ -155,7 +155,11 @@ PyObject * StrokeVertexIterator_castToInterface0DIterator( BPy_StrokeVertexItera } PyObject * StrokeVertexIterator_getObject( BPy_StrokeVertexIterator *self) { - return BPy_StrokeVertex_from_StrokeVertex( self->sv_it->operator*() ); + StrokeVertex *sv = self->sv_it->operator->(); + if( sv ) + return BPy_StrokeVertex_from_StrokeVertex_ptr( sv ); + + Py_RETURN_NONE; } diff --git a/source/blender/freestyle/intern/python/Iterator/BPy_ViewEdgeIterator.cpp b/source/blender/freestyle/intern/python/Iterator/BPy_ViewEdgeIterator.cpp index 0547c173249..16e2750f4a7 100644 --- a/source/blender/freestyle/intern/python/Iterator/BPy_ViewEdgeIterator.cpp +++ b/source/blender/freestyle/intern/python/Iterator/BPy_ViewEdgeIterator.cpp @@ -150,7 +150,7 @@ int ViewEdgeIterator___init__(BPy_ViewEdgeIterator *self, PyObject *args ) PyObject *ViewEdgeIterator_getCurrentEdge( BPy_ViewEdgeIterator *self ) { if( self->ve_it->getCurrentEdge() ) - return BPy_ViewEdge_from_ViewEdge(*( self->ve_it->getCurrentEdge() )); + return BPy_ViewEdge_from_ViewEdge_ptr( self->ve_it->getCurrentEdge() ); Py_RETURN_NONE; } @@ -171,7 +171,7 @@ PyObject *ViewEdgeIterator_setCurrentEdge( BPy_ViewEdgeIterator *self, PyObject PyObject *ViewEdgeIterator_getBegin( BPy_ViewEdgeIterator *self ) { if( self->ve_it->getBegin() ) - return BPy_ViewEdge_from_ViewEdge(*( self->ve_it->getBegin() )); + return BPy_ViewEdge_from_ViewEdge_ptr( self->ve_it->getBegin() ); Py_RETURN_NONE; } @@ -216,7 +216,7 @@ PyObject * ViewEdgeIterator_getObject( BPy_ViewEdgeIterator *self) { ViewEdge *ve = self->ve_it->operator*(); if( ve ) - return BPy_ViewEdge_from_ViewEdge( *ve ); + return BPy_ViewEdge_from_ViewEdge_ptr( ve ); Py_RETURN_NONE; } diff --git a/source/blender/freestyle/intern/python/StrokeShader/BPy_SmoothingShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/BPy_SmoothingShader.cpp new file mode 100644 index 00000000000..80acce599ca --- /dev/null +++ b/source/blender/freestyle/intern/python/StrokeShader/BPy_SmoothingShader.cpp @@ -0,0 +1,120 @@ +#include "BPy_SmoothingShader.h" + +#include "../../stroke/AdvancedStrokeShaders.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/////////////////////////////////////////////////////////////////////////////////////////// + +/*--------------- Python API function prototypes for SmoothingShader instance -----------*/ + static int SmoothingShader___init__( BPy_SmoothingShader* self, PyObject *args); + +/*-----------------------BPy_SmoothingShader type definition ------------------------------*/ + +PyTypeObject SmoothingShader_Type = { + PyObject_HEAD_INIT( NULL ) + 0, /* ob_size */ + "SmoothingShader", /* tp_name */ + sizeof( BPy_SmoothingShader ), /* tp_basicsize */ + 0, /* tp_itemsize */ + + /* methods */ + NULL, /* tp_dealloc */ + NULL, /* printfunc tp_print; */ + NULL, /* getattrfunc tp_getattr; */ + NULL, /* setattrfunc tp_setattr; */ + NULL, /* tp_compare */ + NULL, /* 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 ***/ + NULL, /* struct PyMethodDef *tp_methods; */ + NULL, /* struct PyMemberDef *tp_members; */ + NULL, /* struct PyGetSetDef *tp_getset; */ + &StrokeShader_Type, /* struct _typeobject *tp_base; */ + NULL, /* PyObject *tp_dict; */ + NULL, /* descrgetfunc tp_descr_get; */ + NULL, /* descrsetfunc tp_descr_set; */ + 0, /* long tp_dictoffset; */ + (initproc)SmoothingShader___init__, /* initproc tp_init; */ + NULL, /* allocfunc tp_alloc; */ + NULL, /* 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 +}; + +//------------------------INSTANCE METHODS ---------------------------------- + +int SmoothingShader___init__( BPy_SmoothingShader* self, PyObject *args) +{ + int i1; + double d2, d3, d4, d5, d6, d7, d8; + + if(!( PyArg_ParseTuple(args, "iddddddd", &i1, &d2, &d3, &d4, &d5, &d6, &d7, &d8) )) { + cout << "ERROR: SmoothingShader___init__" << endl; + return -1; + } + + self->py_ss.ss = new SmoothingShader::SmoothingShader(i1, d2, d3, d4, d5, d6, d7, d8); + return 0; + +} + +/////////////////////////////////////////////////////////////////////////////////////////// + +#ifdef __cplusplus +} +#endif diff --git a/source/blender/freestyle/intern/python/StrokeShader/BPy_SmoothingShader.h b/source/blender/freestyle/intern/python/StrokeShader/BPy_SmoothingShader.h new file mode 100644 index 00000000000..18d6ca3cc30 --- /dev/null +++ b/source/blender/freestyle/intern/python/StrokeShader/BPy_SmoothingShader.h @@ -0,0 +1,31 @@ +#ifndef FREESTYLE_PYTHONSMOOTHINGSHADER_H +#define FREESTYLE_PYTHONSMOOTHINGSHADER_H + +#include "../BPy_StrokeShader.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/////////////////////////////////////////////////////////////////////////////////////////// + +#include <Python.h> + +extern PyTypeObject SmoothingShader_Type; + +#define BPy_SmoothingShader_Check(v) ( PyObject_IsInstance( (PyObject *) v, (PyObject *) &SmoothingShader_Type) ) + +/*---------------------------Python BPy_SmoothingShader structure definition----------*/ +typedef struct { + BPy_StrokeShader py_ss; +} BPy_SmoothingShader; + + +/////////////////////////////////////////////////////////////////////////////////////////// + +#ifdef __cplusplus +} +#endif + + +#endif /* FREESTYLE_PYTHONSMOOTHINGSHADER_H */ diff --git a/source/blender/freestyle/intern/python/StrokeShader/BPy_SpatialNoiseShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/BPy_SpatialNoiseShader.cpp index 272884e1645..f8780b7baee 100644 --- a/source/blender/freestyle/intern/python/StrokeShader/BPy_SpatialNoiseShader.cpp +++ b/source/blender/freestyle/intern/python/StrokeShader/BPy_SpatialNoiseShader.cpp @@ -107,7 +107,7 @@ int SpatialNoiseShader___init__( BPy_SpatialNoiseShader* self, PyObject *args) if(!( PyArg_ParseTuple(args, "ffiOO", &f1, &f2, &i3, &obj4, &obj5) - && PyList_Check(obj4) && PyBool_Check(obj5) )) { + && PyBool_Check(obj4) && PyBool_Check(obj5) )) { cout << "ERROR: SpatialNoiseShader___init__" << endl; return -1; } diff --git a/source/blender/freestyle/intern/python/StrokeShader/BPy_StrokeTextureShader.cpp b/source/blender/freestyle/intern/python/StrokeShader/BPy_StrokeTextureShader.cpp index 4d5a56db24b..480a5b2d2ff 100644 --- a/source/blender/freestyle/intern/python/StrokeShader/BPy_StrokeTextureShader.cpp +++ b/source/blender/freestyle/intern/python/StrokeShader/BPy_StrokeTextureShader.cpp @@ -105,7 +105,7 @@ int StrokeTextureShader___init__( BPy_StrokeTextureShader* self, PyObject *args) const char *s1; PyObject *obj2 = 0, *obj3 = 0; - if(!( PyArg_ParseTuple(args, "s|00", &s1, &obj2, &obj3) )) { + if(!( PyArg_ParseTuple(args, "s|OO", &s1, &obj2, &obj3) )) { cout << "ERROR: StrokeTextureShader___init__" << endl; return -1; } diff --git a/source/blender/freestyle/intern/stroke/BasicStrokeShaders.h b/source/blender/freestyle/intern/stroke/BasicStrokeShaders.h index f68971a3966..d54c38bb6cd 100755 --- a/source/blender/freestyle/intern/stroke/BasicStrokeShaders.h +++ b/source/blender/freestyle/intern/stroke/BasicStrokeShaders.h @@ -126,6 +126,11 @@ namespace StrokeShaders { } /*! Destructor.*/ virtual ~IncreasingThicknessShader() {} + + virtual string getName() const { + return "IncreasingThicknessShader"; + } + /*! The shading method. */ virtual void shade(Stroke& stroke) const; @@ -165,6 +170,11 @@ namespace StrokeShaders { } /*! Destructor.*/ virtual ~ConstrainedIncreasingThicknessShader() {} + + virtual string getName() const { + return "ConstrainedIncreasingThicknessShader"; + } + /*! The shading method. */ virtual void shade(Stroke& stroke) const; }; @@ -192,6 +202,10 @@ namespace StrokeShaders { } virtual ~LengthDependingThicknessShader() {} + virtual string getName() const { + return "LengthDependingThicknessShader"; + } + virtual void shade(Stroke& stroke) const; }; @@ -228,6 +242,11 @@ namespace StrokeShaders { _aThickness = 0; } } + + virtual string getName() const { + return "ThicknessVariationPatternShader"; + } + /*! The shading method. */ virtual void shade(Stroke& stroke) const; @@ -258,6 +277,11 @@ namespace StrokeShaders { * The period of the noise signal */ ThicknessNoiseShader(float iAmplitude, float iPeriod); + + virtual string getName() const { + return "ThicknessNoiseShader"; + } + /*! The shading method. */ virtual void shade(Stroke& stroke) const; }; @@ -347,6 +371,11 @@ namespace StrokeShaders { _colorMax[2] = iBM; _colorMax[3] = iAlphaM; } + + virtual string getName() const { + return "IncreasingColorShader"; + } + /*! The shading method. */ virtual void shade(Stroke& stroke) const; }; @@ -376,6 +405,11 @@ namespace StrokeShaders { _aVariation = 0; } } + + virtual string getName() const { + return "ColorVariationPatternShader"; + } + /*! The shading method. */ virtual void shade(Stroke& stroke) const; @@ -400,6 +434,10 @@ namespace StrokeShaders { : StrokeShader() {_coefficient=coeff;} + virtual string getName() const { + return "MaterialColorShader"; + } + virtual void shade(Stroke& stroke) const; }; @@ -416,6 +454,11 @@ namespace StrokeShaders { _orientation=iOrientation; _orientation.normalize(); } + + virtual string getName() const { + return "CalligraphicColorShader"; + } + virtual void shade(Stroke& stroke) const; }; @@ -438,6 +481,11 @@ namespace StrokeShaders { * The period of the noise signal */ ColorNoiseShader(float iAmplitude, float iPeriod); + + virtual string getName() const { + return "ColorNoiseShader"; + } + /*! The shading method. */ virtual void shade(Stroke& stroke) const; }; @@ -477,6 +525,11 @@ namespace StrokeShaders { { _textureId = id; } + + virtual string getName() const { + return "TextureAssignerShader"; + } + /*! The shading method */ virtual void shade(Stroke& stroke) const; @@ -526,6 +579,11 @@ namespace StrokeShaders { _mediumType = mediumType; _tips = iTips; } + + virtual string getName() const { + return "StrokeTextureShader"; + } + /*! The shading method */ virtual void shade(Stroke& stroke) const; @@ -554,6 +612,11 @@ namespace StrokeShaders { { _amount = iAmount; } + + virtual string getName() const { + return "BackboneStretcherShader"; + } + /*! The shading method */ virtual void shade(Stroke& stroke) const; }; @@ -577,6 +640,11 @@ namespace StrokeShaders { { _sampling = sampling; } + + virtual string getName() const { + return "SamplingShader"; + } + /*! The shading method */ virtual void shade(Stroke& stroke) const; }; @@ -593,6 +661,10 @@ namespace StrokeShaders { _amount = iAmount; } + virtual string getName() const { + return "ExternalContourStretcherShader"; + } + virtual void shade(Stroke& stroke) const; }; @@ -604,6 +676,10 @@ namespace StrokeShaders { : StrokeShader() {} + virtual string getName() const { + return "BSplineShader"; + } + virtual void shade(Stroke& stroke) const; }; @@ -630,6 +706,10 @@ namespace StrokeShaders { : StrokeShader() {_error=error;} + virtual string getName() const { + return "BezierCurveShader"; + } + /*! The shading method */ virtual void shade(Stroke& stroke) const; }; @@ -661,6 +741,11 @@ namespace StrokeShaders { _amount = iAmount; _curvatureThreshold = iThreshold; } + + virtual string getName() const { + return "InflateShader"; + } + /*! The shading method */ virtual void shade(Stroke& stroke) const; }; @@ -690,6 +775,11 @@ namespace StrokeShaders { */ PolygonalizationShader(float iError) : StrokeShader() {_error = iError;} + + virtual string getName() const { + return "PolygonalizationShader"; + } + /*! The shading method */ virtual void shade(Stroke& stroke) const; }; @@ -720,6 +810,11 @@ namespace StrokeShaders { */ GuidingLinesShader(float iOffset) : StrokeShader() {_offset = iOffset;} + + virtual string getName() const { + return "GuidingLinesShader"; + } + /*! The shading method */ virtual void shade(Stroke& stroke) const; }; @@ -739,6 +834,10 @@ namespace StrokeShaders { /*! Destructor. */ virtual ~TipRemoverShader () {} /*! The shading method */ + virtual string getName() const { + return "TipRemoverShader"; + } + virtual void shade(Stroke &stroke) const; protected: diff --git a/source/blender/freestyle/intern/stroke/Operators.cpp b/source/blender/freestyle/intern/stroke/Operators.cpp index 39914cbef1a..6221f6c16f1 100755 --- a/source/blender/freestyle/intern/stroke/Operators.cpp +++ b/source/blender/freestyle/intern/stroke/Operators.cpp @@ -814,10 +814,14 @@ Stroke* createStroke(Interface1D& inter) { inline void applyShading(Stroke& stroke, vector<StrokeShader*>& shaders) { - for (vector<StrokeShader*>::iterator it = shaders.begin(); - it != shaders.end(); - ++it) - (*it)->shade(stroke); + for (vector<StrokeShader*>::iterator it = shaders.begin(); it != shaders.end(); ++it) { + StrokeShader *ss = *it; + string name( ss->py_ss ? PyString_AsString(PyObject_CallMethod(ss->py_ss, "getName", "")) : ss->getName() ); + + cout << "Shading: " << name << endl; + (*it)->shade(stroke); + + } } @@ -832,7 +836,8 @@ void Operators::create(UnaryPredicate1D& pred, vector<StrokeShader*> shaders) { ++it) { if (!pred(**it)) continue; - Stroke* stroke = createStroke(**it); + + Stroke* stroke = createStroke(**it); if (stroke) { applyShading(*stroke, shaders); canvas->RenderStroke(stroke); diff --git a/source/blender/freestyle/intern/stroke/Stroke.cpp b/source/blender/freestyle/intern/stroke/Stroke.cpp index a1277611a90..dbb49bab45d 100755 --- a/source/blender/freestyle/intern/stroke/Stroke.cpp +++ b/source/blender/freestyle/intern/stroke/Stroke.cpp @@ -45,6 +45,9 @@ StrokeAttribute::StrokeAttribute() _userAttributesVec2f = 0; _userAttributesVec3f = 0; _visible = true; + + py_sa = 0; + } StrokeAttribute::StrokeAttribute(const StrokeAttribute& iBrother) { @@ -66,6 +69,10 @@ StrokeAttribute::StrokeAttribute(const StrokeAttribute& iBrother) _userAttributesVec3f = new Vec3fMap(*iBrother._userAttributesVec3f); else _userAttributesVec3f = 0; + + py_sa = 0; + + } StrokeAttribute::StrokeAttribute( float iRColor, float iGColor, float iBColor, float iAlpha, @@ -85,6 +92,9 @@ StrokeAttribute::StrokeAttribute( float iRColor, float iGColor, float iBColor, _userAttributesReal = 0; _userAttributesVec2f = 0; _userAttributesVec3f = 0; + +py_sa = 0; + } StrokeAttribute::StrokeAttribute(const StrokeAttribute& a1, const StrokeAttribute& a2, float t) @@ -136,7 +146,9 @@ StrokeAttribute::StrokeAttribute(const StrokeAttribute& a1, const StrokeAttribut _userAttributesVec3f = 0; } + py_sa = 0; } + StrokeAttribute::~StrokeAttribute() { if(_userAttributesReal){ @@ -404,11 +416,8 @@ Stroke::Stroke(const Stroke& iBrother) _mediumType = iBrother._mediumType; _textureId = iBrother._textureId; _tips = iBrother._tips; + _rep = new StrokeRep(*(iBrother._rep)); - if( iBrother._rep ) - _rep = new StrokeRep(*(iBrother._rep)); - else - _rep = new StrokeRep(this); } Stroke::~Stroke() diff --git a/source/blender/freestyle/intern/stroke/Stroke.h b/source/blender/freestyle/intern/stroke/Stroke.h index 3df57341e5f..3b3a6a5ab2d 100755 --- a/source/blender/freestyle/intern/stroke/Stroke.h +++ b/source/blender/freestyle/intern/stroke/Stroke.h @@ -52,6 +52,8 @@ class LIB_STROKE_EXPORT StrokeAttribute { public: + PyObject *py_sa; + /*! default constructor */ StrokeAttribute(); /*! Copy constructor */ diff --git a/source/blender/freestyle/intern/stroke/StrokeShader.h b/source/blender/freestyle/intern/stroke/StrokeShader.h index f92895564d8..cb7ceeca09f 100755 --- a/source/blender/freestyle/intern/stroke/StrokeShader.h +++ b/source/blender/freestyle/intern/stroke/StrokeShader.h @@ -82,7 +82,7 @@ public: * shader's name. */ virtual string getName() const { - return "StrokeShader"; + return "StrokeShader"; } /*! The shading method. This method must * be overloaded by inherited classes. @@ -119,7 +119,7 @@ public: 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); + 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/Interface0D.h b/source/blender/freestyle/intern/view_map/Interface0D.h index eaa6d31829b..89d8f606264 100755 --- a/source/blender/freestyle/intern/view_map/Interface0D.h +++ b/source/blender/freestyle/intern/view_map/Interface0D.h @@ -40,6 +40,7 @@ using namespace std; #include "../system/Iterator.h" //soc +#include "../python/Director.h" // // Interface0D @@ -56,6 +57,10 @@ class Interface0D { public: + PyObject *py_if0D; + + /*! Default constructor */ + Interface0D() { py_if0D = 0; } virtual ~Interface0D() {}; //soc /*! Returns the string "Interface0D".*/ @@ -67,94 +72,187 @@ public: /*! Returns the 3D x coordinate of the point. */ virtual real getX() const { - cerr << "Warning: method getX() not implemented" << endl; - return 0; + string name( py_if0D ? PyString_AsString(PyObject_CallMethod(py_if0D, "getExactTypeName", "")) : getExactTypeName() ); + + if( py_if0D && PyObject_HasAttrString(py_if0D, "getX") ) { + return Director_BPy_Interface0D_getX(py_if0D); + } else { + cerr << "Warning: " << name << " getX() not implemented" << endl; + return 0; + } } + /*! Returns the 3D y coordinate of the point. */ virtual real getY() const { - cerr << "Warning: method getY() not implemented" << endl; - return 0; + string name( py_if0D ? PyString_AsString(PyObject_CallMethod(py_if0D, "getExactTypeName", "")) : getExactTypeName() ); + + if( py_if0D && PyObject_HasAttrString(py_if0D, "getY") ) { + return Director_BPy_Interface0D_getY(py_if0D); + } else { + cerr << "Warning: " << name << " getY() not implemented" << endl; + return 0; + } } /*! Returns the 3D z coordinate of the point. */ virtual real getZ() const { - cerr << "Warning: method getZ() not implemented" << endl; - return 0; + string name( py_if0D ? PyString_AsString(PyObject_CallMethod(py_if0D, "getExactTypeName", "")) : getExactTypeName() ); + + if( py_if0D && PyObject_HasAttrString(py_if0D, "getZ") ) { + return Director_BPy_Interface0D_getZ(py_if0D); + } else { + cerr << "Warning: " << name << " getZ() not implemented" << endl; + return 0; + } } /*! Returns the 3D point. */ virtual Geometry::Vec3f getPoint3D() const { - cerr << "Warning: method getPoint3D() not implemented" << endl; - return 0; + string name( py_if0D ? PyString_AsString(PyObject_CallMethod(py_if0D, "getExactTypeName", "")) : getExactTypeName() ); + + if( py_if0D && PyObject_HasAttrString(py_if0D, "getPoint3D") ) { + return Director_BPy_Interface0D_getPoint3D(py_if0D); + } else { + cerr << "Warning: " << name << " getPoint3D() not implemented" << endl; + return 0; + } } /*! Returns the 2D x coordinate of the point. */ virtual real getProjectedX() const { - cerr << "Warning: method getProjectedX() not implemented" << endl; - return 0; + string name( py_if0D ? PyString_AsString(PyObject_CallMethod(py_if0D, "getExactTypeName", "")) : getExactTypeName() ); + + if( py_if0D && PyObject_HasAttrString(py_if0D, "getProjectedX") ) { + return Director_BPy_Interface0D_getProjectedX(py_if0D); + } else { + cerr << "Warning: " << name << " getProjectedX() not implemented" << endl; + return 0; + } } /*! Returns the 2D y coordinate of the point. */ virtual real getProjectedY() const { - cerr << "Warning: method getProjectedY() not implemented" << endl; - return 0; + string name( py_if0D ? PyString_AsString(PyObject_CallMethod(py_if0D, "getExactTypeName", "")) : getExactTypeName() ); + + if( py_if0D && PyObject_HasAttrString(py_if0D, "getProjectedY") ) { + return Director_BPy_Interface0D_getProjectedY(py_if0D); + } else { + cerr << "Warning: " << name << " getProjectedY() not implemented" << endl; + return 0; + } } /*! Returns the 2D z coordinate of the point. */ virtual real getProjectedZ() const { - cerr << "Warning: method getProjectedZ() not implemented" << endl; - return 0; + string name( py_if0D ? PyString_AsString(PyObject_CallMethod(py_if0D, "getExactTypeName", "")) : getExactTypeName() ); + + if( py_if0D && PyObject_HasAttrString(py_if0D, "getProjectedZ") ) { + return Director_BPy_Interface0D_getProjectedZ(py_if0D); + } else { + cerr << "Warning: " << name << " getProjectedZ() not implemented" << endl; + return 0; + } } /*! Returns the 2D point. */ virtual Geometry::Vec2f getPoint2D() const { - cerr << "Warning: method getPoint2D() not implemented" << endl; - return 0; - } + string name( py_if0D ? PyString_AsString(PyObject_CallMethod(py_if0D, "getExactTypeName", "")) : getExactTypeName() ); + if( py_if0D && PyObject_HasAttrString(py_if0D, "getPoint2D") ) { + return Director_BPy_Interface0D_getPoint2D(py_if0D); + } else { + cerr << "Warning: " << name << " getPoint2D() not implemented" << endl; + return 0; + } + } + /*! Returns the FEdge that lies between this Interface0D and the * Interface0D given as argument. */ virtual FEdge* getFEdge(Interface0D&) { - cerr << "Warning: method getFEdge() not implemented" << endl; - return 0; + string name( py_if0D ? PyString_AsString(PyObject_CallMethod(py_if0D, "getExactTypeName", "")) : getExactTypeName() ); + + if( py_if0D && PyObject_HasAttrString(py_if0D, "getFEdge") ) { + return Director_BPy_Interface0D_getFEdge(py_if0D); + } else { + cerr << "Warning: " << name << " getFEdge() not implemented" << endl; + return 0; + } } /*! Returns the Id of the point. */ virtual Id getId() const { - cerr << "Warning: method getId() not implemented" << endl; - return Id(0, 0); + string name( py_if0D ? PyString_AsString(PyObject_CallMethod(py_if0D, "getExactTypeName", "")) : getExactTypeName() ); + + if( py_if0D && PyObject_HasAttrString(py_if0D, "getId") ) { + return Director_BPy_Interface0D_getId(py_if0D); + } else { + cerr << "Warning: " << name << " getId() not implemented" << endl; + return 0; + } } /*! Returns the nature of the point. */ virtual Nature::VertexNature getNature() const { - cerr << "Warning: method getNature() not implemented" << endl; - return Nature::POINT; - } + string name( py_if0D ? PyString_AsString(PyObject_CallMethod(py_if0D, "getExactTypeName", "")) : getExactTypeName() ); + + if( py_if0D && PyObject_HasAttrString(py_if0D, "getNature") ) { + return Director_BPy_Interface0D_getNature(py_if0D); + } else { + cerr << "Warning: " << name << " getNature() not implemented" << endl; + return Nature::POINT; + } + } + /*! Cast the Interface0D in SVertex if it can be. */ virtual SVertex * castToSVertex(){ - cerr << "Warning: can't cast this Interface0D in SVertex" << endl; - return 0; + string name( py_if0D ? PyString_AsString(PyObject_CallMethod(py_if0D, "getExactTypeName", "")) : getExactTypeName() ); + + if( py_if0D && PyObject_HasAttrString(py_if0D, "castToSVertex") ) { + return Director_BPy_Interface0D_castToSVertex(py_if0D); + } else { + cerr << "Warning: " << name << " castToSVertex() not implemented" << endl; + return 0; + } } /*! Cast the Interface0D in ViewVertex if it can be. */ virtual ViewVertex * castToViewVertex(){ - cerr << "Warning: can't cast this Interface0D in ViewVertex" << endl; - return 0; + string name( py_if0D ? PyString_AsString(PyObject_CallMethod(py_if0D, "getExactTypeName", "")) : getExactTypeName() ); + + if( py_if0D && PyObject_HasAttrString(py_if0D, "castToViewVertex") ) { + return Director_BPy_Interface0D_castToViewVertex(py_if0D); + } else { + cerr << "Warning: " << name << " castToViewVertex() not implemented" << endl; + return 0; + } } /*! Cast the Interface0D in NonTVertex if it can be. */ virtual NonTVertex * castToNonTVertex(){ - cerr << "Warning: can't cast this Interface0D in NonTVertex" << endl; - return 0; + string name( py_if0D ? PyString_AsString(PyObject_CallMethod(py_if0D, "getExactTypeName", "")) : getExactTypeName() ); + + if( py_if0D && PyObject_HasAttrString(py_if0D, "castToNonTVertex") ) { + return Director_BPy_Interface0D_castToNonTVertex(py_if0D); + } else { + cerr << "Warning: " << name << " castToNonTVertex() not implemented" << endl; + return 0; + } } /*! Cast the Interface0D in TVertex if it can be. */ virtual TVertex * castToTVertex(){ - cerr << "Warning: can't cast this Interface0D in TVertex" << endl; - return 0; + string name( py_if0D ? PyString_AsString(PyObject_CallMethod(py_if0D, "getExactTypeName", "")) : getExactTypeName() ); + + if( py_if0D && PyObject_HasAttrString(py_if0D, "castToTVertex") ) { + return Director_BPy_Interface0D_castToTVertex(py_if0D); + } else { + cerr << "Warning: " << name << " castToTVertex() not implemented" << endl; + return 0; + } } + }; diff --git a/source/blender/freestyle/intern/view_map/Interface1D.h b/source/blender/freestyle/intern/view_map/Interface1D.h index 55a2aece91c..44822005705 100755 --- a/source/blender/freestyle/intern/view_map/Interface1D.h +++ b/source/blender/freestyle/intern/view_map/Interface1D.h @@ -212,22 +212,41 @@ public: /*! Returns the 2D length of the 1D element. */ virtual real getLength2D() const { - cerr << "Warning: method getLength2D() not implemented" << endl; - return 0; + string name( py_if1D ? PyString_AsString(PyObject_CallMethod(py_if1D, "getExactTypeName", "")) : getExactTypeName() ); + + if( py_if1D && PyObject_HasAttrString(py_if1D, "getLength2D") ) { + return Director_BPy_Interface1D_getLength2D(py_if1D); + } else { + cerr << "Warning: " << name << " getLength2D() not implemented" << endl; + return 0; + } } /*! Returns the Id of the 1D element .*/ virtual Id getId() const { - cerr << "Warning: method getId() not implemented" << endl; - return Id(0, 0); - } + string name( py_if1D ? PyString_AsString(PyObject_CallMethod(py_if1D, "getExactTypeName", "")) : getExactTypeName() ); + + if( py_if1D && PyObject_HasAttrString(py_if1D, "getId") ) { + return Director_BPy_Interface1D_getId(py_if1D); + } else { + cerr << "Warning: " << name << " getId() not implemented" << endl; + return Id(0, 0); + } + } + // FIXME: ce truc n'a rien a faire la...(c une requete complexe qui doit etre ds les Function1D) /*! Returns the nature of the 1D element. */ virtual Nature::EdgeNature getNature() const { - cerr << "Warning: method getNature() not implemented" << endl; - return Nature::NO_FEATURE; - } + string name( py_if1D ? PyString_AsString(PyObject_CallMethod(py_if1D, "getExactTypeName", "")) : getExactTypeName() ); + + if( py_if1D && PyObject_HasAttrString(py_if1D, "getNature") ) { + return Director_BPy_Interface1D_getNature(py_if1D); + } else { + cerr << "Warning: " << name << " getNature() not implemented" << endl; + return Nature::NO_FEATURE; + } + } /*! Returns the time stamp of the 1D element. Mainly used for selection. */ virtual unsigned getTimeStamp() const { diff --git a/source/blender/freestyle/style_modules_blender/ChainingIterators.py b/source/blender/freestyle/style_modules_blender/ChainingIterators.py index 9e4d467d1db..30488c9ef30 100755 --- a/source/blender/freestyle/style_modules_blender/ChainingIterators.py +++ b/source/blender/freestyle/style_modules_blender/ChainingIterators.py @@ -37,6 +37,8 @@ class pyChainSilhouetteIterator(ChainingIterator): ChainingIterator.__init__(self, stayInSelection, 1,None,1) def getExactTypeName(self): return "pyChainSilhouetteIterator" + def init(self): + pass def traverse(self, iter): winner = None it = AdjacencyIterator(iter) @@ -88,6 +90,8 @@ class pyChainSilhouetteGenericIterator(ChainingIterator): ChainingIterator.__init__(self, stayInSelection, stayInUnvisited,None,1) def getExactTypeName(self): return "pyChainSilhouetteGenericIterator" + def init(self): + pass def traverse(self, iter): winner = None it = AdjacencyIterator(iter) @@ -384,6 +388,8 @@ class pyFillOcclusionsAbsoluteChainingIterator(ChainingIterator): self._length = float(length) def getExactTypeName(self): return "pySmallFillOcclusionsChainingIterator" + def init(self): + pass def traverse(self, iter): winner = None winnerOrientation = 0 @@ -665,6 +671,8 @@ class pyNoIdChainSilhouetteIterator(ChainingIterator): ChainingIterator.__init__(self, stayInSelection, 1,None,1) def getExactTypeName(self): return "pyChainSilhouetteIterator" + def init(self): + pass def traverse(self, iter): winner = None it = AdjacencyIterator(iter) diff --git a/source/blender/freestyle/style_modules_blender/freestyle_init.py b/source/blender/freestyle/style_modules_blender/freestyle_init.py index ba641bd0e3b..504aad25b87 100644 --- a/source/blender/freestyle/style_modules_blender/freestyle_init.py +++ b/source/blender/freestyle/style_modules_blender/freestyle_init.py @@ -1,3 +1,4 @@ +from Blender.Mathutils import Vector import Blender.Freestyle class BBox(Blender.Freestyle.BBox): @@ -174,6 +175,9 @@ class PolygonalizationShader(Blender.Freestyle.PolygonalizationShader): class SamplingShader(Blender.Freestyle.SamplingShader): pass +class SmoothingShader(Blender.Freestyle.SmoothingShader): + pass + class SpatialNoiseShader(Blender.Freestyle.SpatialNoiseShader): pass diff --git a/source/blender/freestyle/style_modules_blender/japanese_bigbrush.py b/source/blender/freestyle/style_modules_blender/japanese_bigbrush.py index b41c6d7df17..7f109598aaa 100755 --- a/source/blender/freestyle/style_modules_blender/japanese_bigbrush.py +++ b/source/blender/freestyle/style_modules_blender/japanese_bigbrush.py @@ -32,7 +32,6 @@ from PredicatesB1D import * from Functions0D import * from shaders import * - Operators.select(QuantitativeInvisibilityUP1D(0)) Operators.bidirectionalChain(ChainSilhouetteIterator(),NotUP1D(QuantitativeInvisibilityUP1D(0))) ## Splits strokes at points of highest 2D curavture @@ -48,11 +47,13 @@ shaders_list = [ pySamplingShader(10), BezierCurveShader(30), SamplingShader(50), + ConstantThicknessShader(10), pyNonLinearVaryingThicknessShader(4,25, 0.6), TextureAssignerShader(6), ConstantColorShader(0.2, 0.2, 0.2,1.0), TipRemoverShader(10) ] + ## Use the causal density to avoid cluttering Operators.create(pyDensityUP1D(8,0.4, IntegrationType.MEAN), shaders_list) diff --git a/source/blender/freestyle/style_modules_blender/qi0_not_external_contour.py b/source/blender/freestyle/style_modules_blender/qi0_not_external_contour.py index c1151f2c231..eed41af32b4 100755 --- a/source/blender/freestyle/style_modules_blender/qi0_not_external_contour.py +++ b/source/blender/freestyle/style_modules_blender/qi0_not_external_contour.py @@ -34,7 +34,7 @@ Operators.select(upred) Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(upred)) shaders_list = [ SamplingShader(4), - SpatialNoiseShader(4, 150, 2, 1, 1), + SpatialNoiseShader(4, 150, 2, True, True), IncreasingThicknessShader(2, 5), BackboneStretcherShader(20), IncreasingColorShader(1,0,0,1,0,1,0,1), diff --git a/source/blender/freestyle/style_modules_blender/sequentialsplit_sketchy.py b/source/blender/freestyle/style_modules_blender/sequentialsplit_sketchy.py index c371ed48d64..53fa03103aa 100755 --- a/source/blender/freestyle/style_modules_blender/sequentialsplit_sketchy.py +++ b/source/blender/freestyle/style_modules_blender/sequentialsplit_sketchy.py @@ -55,11 +55,11 @@ upred = QuantitativeInvisibilityUP1D(0) Operators.select(upred) Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(upred)) ## starting and stopping predicates: -start = pyVertexNatureUP0D(Nature.NON_Nature.T_VERTEX) +start = pyVertexNatureUP0D(Nature.NON_T_VERTEX) stop = pyBackTVertexUP0D() Operators.sequentialSplit(start, stop, 10) shaders_list = [ - SpatialNoiseShader(7, 120, 2, 1, 1), + SpatialNoiseShader(7, 120, 2, True, True), IncreasingThicknessShader(5, 8), ConstantColorShader(0.2, 0.2, 0.2, 1), TextureAssignerShader(4) diff --git a/source/blender/freestyle/style_modules_blender/split_at_highest_2d_curvatures.py b/source/blender/freestyle/style_modules_blender/split_at_highest_2d_curvatures.py index f780137ef05..52cc10a9c60 100755 --- a/source/blender/freestyle/style_modules_blender/split_at_highest_2d_curvatures.py +++ b/source/blender/freestyle/style_modules_blender/split_at_highest_2d_curvatures.py @@ -28,6 +28,7 @@ from freestyle_init import * from logical_operators import * +from PredicatesU0D import * from PredicatesU1D import * from Functions0D import * |