From 5fed0560d9184d9dd64625ce6af70f67e0ad0960 Mon Sep 17 00:00:00 2001 From: Tamito Kajiyama Date: Sun, 19 Jul 2009 23:17:30 +0000 Subject: * Introspection-based automatic type conversion from a generic C++ object to a specific Python object. The conversion takes place in the following places. - Interface0DIterator_getObject (BPy_Interface0DIterator.cpp) - Director_BPy_BinaryPredicate1D___call__ (Director.cpp) - Director_BPy_UnaryPredicate1D___call__ (Director.cpp) - SVertex_viewvertex (BPy_SVertex.cpp) - BPy_FEdge_from_FEdge (BPy_Convert.cpp) This is a tentative list and more conversions are expected to be added. * Added the following two converter functions to BPy_Convert.{cpp,h}: - BPy_NonTVertex_from_NonTVertex_ptr - BPy_TVertex_from_TVertex_ptr --- .../freestyle/intern/python/BPy_Convert.cpp | 41 ++++++++++++++++++++-- .../blender/freestyle/intern/python/BPy_Convert.h | 2 ++ .../blender/freestyle/intern/python/Director.cpp | 29 +++++++++++++-- .../intern/python/Interface0D/BPy_SVertex.cpp | 8 ++++- .../python/Iterator/BPy_Interface0DIterator.cpp | 18 +++++++++- 5 files changed, 90 insertions(+), 8 deletions(-) (limited to 'source/blender') diff --git a/source/blender/freestyle/intern/python/BPy_Convert.cpp b/source/blender/freestyle/intern/python/BPy_Convert.cpp index a3777d6415c..1d9dc372bd0 100644 --- a/source/blender/freestyle/intern/python/BPy_Convert.cpp +++ b/source/blender/freestyle/intern/python/BPy_Convert.cpp @@ -9,11 +9,15 @@ #include "Interface0D/CurvePoint/BPy_StrokeVertex.h" #include "Interface0D/BPy_SVertex.h" #include "Interface0D/BPy_ViewVertex.h" +#include "Interface0D/ViewVertex/BPy_NonTVertex.h" +#include "Interface0D/ViewVertex/BPy_TVertex.h" #include "BPy_Interface1D.h" #include "Interface1D/BPy_FEdge.h" #include "Interface1D/BPy_Stroke.h" #include "Interface1D/BPy_ViewEdge.h" #include "Interface1D/Curve/BPy_Chain.h" +#include "Interface1D/FEdge/BPy_FEdgeSharp.h" +#include "Interface1D/FEdge/BPy_FEdgeSmooth.h" #include "BPy_Nature.h" #include "BPy_MediumType.h" #include "BPy_SShape.h" @@ -102,9 +106,22 @@ PyObject * BPy_SVertex_from_SVertex_ptr( SVertex *sv ) { } PyObject * BPy_FEdge_from_FEdge( FEdge& fe ) { - PyObject *py_fe = FEdge_Type.tp_new( &FEdge_Type, 0, 0 ); - ((BPy_FEdge *) py_fe)->fe = new FEdge( fe ); - ((BPy_FEdge *) py_fe)->py_if1D.if1D = ((BPy_FEdge *) py_fe)->fe; + PyObject *py_fe; + if (typeid(fe) == typeid(FEdgeSharp)) { + py_fe = FEdgeSharp_Type.tp_new( &FEdgeSharp_Type, 0, 0 ); + ((BPy_FEdgeSharp *) py_fe)->fes = new FEdgeSharp( dynamic_cast(fe) ); + ((BPy_FEdgeSharp *) py_fe)->py_fe.fe = ((BPy_FEdgeSharp *) py_fe)->fes; + ((BPy_FEdgeSharp *) py_fe)->py_fe.py_if1D.if1D = ((BPy_FEdgeSharp *) py_fe)->fes; + } else if (typeid(fe) == typeid(FEdgeSmooth)) { + py_fe = FEdgeSmooth_Type.tp_new( &FEdgeSmooth_Type, 0, 0 ); + ((BPy_FEdgeSmooth *) py_fe)->fes = new FEdgeSmooth( dynamic_cast(fe) ); + ((BPy_FEdgeSmooth *) py_fe)->py_fe.fe = ((BPy_FEdgeSmooth *) py_fe)->fes; + ((BPy_FEdgeSmooth *) py_fe)->py_fe.py_if1D.if1D = ((BPy_FEdgeSmooth *) py_fe)->fes; + } else { + py_fe = FEdge_Type.tp_new( &FEdge_Type, 0, 0 ); + ((BPy_FEdge *) py_fe)->fe = new FEdge( fe ); + ((BPy_FEdge *) py_fe)->py_if1D.if1D = ((BPy_FEdge *) py_fe)->fe; + } return py_fe; } @@ -162,6 +179,24 @@ PyObject * BPy_ViewVertex_from_ViewVertex_ptr( ViewVertex *vv ) { return py_vv; } +PyObject * BPy_NonTVertex_from_NonTVertex_ptr( NonTVertex *ntv ) { + PyObject *py_ntv = NonTVertex_Type.tp_new( &NonTVertex_Type, 0, 0 ); + ((BPy_NonTVertex *) py_ntv)->ntv = ntv; + ((BPy_NonTVertex *) py_ntv)->py_vv.vv = ((BPy_NonTVertex *) py_ntv)->ntv; + ((BPy_NonTVertex *) py_ntv)->py_vv.py_if0D.if0D = ((BPy_NonTVertex *) py_ntv)->ntv; + + return py_ntv; +} + +PyObject * BPy_TVertex_from_TVertex_ptr( TVertex *tv ) { + PyObject *py_tv = TVertex_Type.tp_new( &TVertex_Type, 0, 0 ); + ((BPy_TVertex *) py_tv)->tv = tv; + ((BPy_TVertex *) py_tv)->py_vv.vv = ((BPy_TVertex *) py_tv)->tv; + ((BPy_TVertex *) py_tv)->py_vv.py_if0D.if0D = ((BPy_TVertex *) py_tv)->tv; + + return py_tv; +} + PyObject * BPy_BBox_from_BBox( BBox< Vec3r > &bb ) { PyObject *py_bb = BBox_Type.tp_new( &BBox_Type, 0, 0 ); ((BPy_BBox *) py_bb)->bb = new BBox< Vec3r >( bb ); diff --git a/source/blender/freestyle/intern/python/BPy_Convert.h b/source/blender/freestyle/intern/python/BPy_Convert.h index 099a8ed5804..3d0e3adf235 100644 --- a/source/blender/freestyle/intern/python/BPy_Convert.h +++ b/source/blender/freestyle/intern/python/BPy_Convert.h @@ -90,6 +90,8 @@ 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_NonTVertex_from_NonTVertex_ptr( NonTVertex *ntv ); +PyObject * BPy_TVertex_from_TVertex_ptr( TVertex *tv ); PyObject * BPy_ViewEdge_from_ViewEdge_ptr( ViewEdge *ve ); PyObject * BPy_Chain_from_Chain_ptr( Chain* c ); PyObject * BPy_ViewShape_from_ViewShape( ViewShape& vs ); diff --git a/source/blender/freestyle/intern/python/Director.cpp b/source/blender/freestyle/intern/python/Director.cpp index 84560de67a8..dd4688515a7 100644 --- a/source/blender/freestyle/intern/python/Director.cpp +++ b/source/blender/freestyle/intern/python/Director.cpp @@ -59,8 +59,21 @@ int Director_BPy_BinaryPredicate0D___call__( PyObject *obj, Interface0D& i1, Int // BinaryPredicate1D: __call__ int Director_BPy_BinaryPredicate1D___call__( PyObject *obj, Interface1D& i1, Interface1D& i2) { - PyObject *arg1 = BPy_Interface1D_from_Interface1D(i1); - PyObject *arg2 = BPy_Interface1D_from_Interface1D(i2); + PyObject *arg1, *arg2; + if (typeid(i1) == typeid(ViewEdge)) { + arg1 = BPy_ViewEdge_from_ViewEdge_ptr(dynamic_cast(&i1)); + arg2 = BPy_ViewEdge_from_ViewEdge_ptr(dynamic_cast(&i2)); + } else if (typeid(i1) == typeid(Chain)) { + arg1 = BPy_Chain_from_Chain_ptr(dynamic_cast(&i1)); + arg2 = BPy_Chain_from_Chain_ptr(dynamic_cast(&i2)); + } else if (typeid(i1) == typeid(Stroke)) { + arg1 = BPy_Stroke_from_Stroke_ptr(dynamic_cast(&i1)); + arg2 = BPy_Stroke_from_Stroke_ptr(dynamic_cast(&i2)); + } else { + cerr << "Warning: cast to " + i1.getExactTypeName() + " not implemented" << endl; + arg1 = BPy_Interface1D_from_Interface1D(i1); + arg2 = BPy_Interface1D_from_Interface1D(i2); + } PyObject *result = PyObject_CallMethod( obj, "__call__", "OO", arg1, arg2 ); Py_DECREF(arg1); Py_DECREF(arg2); @@ -87,7 +100,17 @@ int Director_BPy_UnaryPredicate0D___call__( PyObject *obj, Interface0DIterator& // UnaryPredicate1D: __call__ int Director_BPy_UnaryPredicate1D___call__( PyObject *obj, Interface1D& if1D) { - PyObject *arg = BPy_Interface1D_from_Interface1D(if1D); + PyObject *arg; + if (typeid(if1D) == typeid(ViewEdge)) { + arg = BPy_ViewEdge_from_ViewEdge_ptr(dynamic_cast(&if1D)); + } else if (typeid(if1D) == typeid(Chain)) { + arg = BPy_Chain_from_Chain_ptr(dynamic_cast(&if1D)); + } else if (typeid(if1D) == typeid(Stroke)) { + arg = BPy_Stroke_from_Stroke_ptr(dynamic_cast(&if1D)); + } else { + cerr << "Warning: cast to " + if1D.getExactTypeName() + " not implemented" << endl; + arg = BPy_Interface1D_from_Interface1D(if1D); + } PyObject *result = PyObject_CallMethod( obj, "__call__", "O", arg ); Py_DECREF(arg); if (!result) diff --git a/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp index db27f343ebc..87d3ef4ecd0 100644 --- a/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp +++ b/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp @@ -181,7 +181,13 @@ PyObject * SVertex_normalsSize( BPy_SVertex *self ) { } PyObject * SVertex_viewvertex( BPy_SVertex *self ) { - return BPy_ViewVertex_from_ViewVertex_ptr( self->sv->viewvertex() ); + ViewVertex *vv = self->sv->viewvertex(); + if (!vv) + Py_RETURN_NONE; + if (typeid(*vv) == typeid(NonTVertex)) + return BPy_NonTVertex_from_NonTVertex_ptr( dynamic_cast(vv) ); + else + return BPy_TVertex_from_TVertex_ptr( dynamic_cast(vv) ); } PyObject *SVertex_setPoint3D( BPy_SVertex *self , PyObject *args) { diff --git a/source/blender/freestyle/intern/python/Iterator/BPy_Interface0DIterator.cpp b/source/blender/freestyle/intern/python/Iterator/BPy_Interface0DIterator.cpp index 5c35aa612a6..096baad2936 100644 --- a/source/blender/freestyle/intern/python/Iterator/BPy_Interface0DIterator.cpp +++ b/source/blender/freestyle/intern/python/Iterator/BPy_Interface0DIterator.cpp @@ -136,7 +136,23 @@ PyObject * Interface0DIterator_u( BPy_Interface0DIterator *self ) { } PyObject * Interface0DIterator_getObject(BPy_Interface0DIterator *self) { - return BPy_Interface0D_from_Interface0D( self->if0D_it->operator*() ); + Interface0D &if0D = self->if0D_it->operator*(); + if (typeid(if0D) == typeid(CurvePoint)) { + return BPy_CurvePoint_from_CurvePoint_ptr(dynamic_cast(&if0D)); + } else if (typeid(if0D) == typeid(StrokeVertex)) { + return BPy_StrokeVertex_from_StrokeVertex_ptr(dynamic_cast(&if0D)); + } else if (typeid(if0D) == typeid(SVertex)) { + return BPy_SVertex_from_SVertex_ptr(dynamic_cast(&if0D)); + } else if (typeid(if0D) == typeid(ViewVertex)) { + return BPy_ViewVertex_from_ViewVertex_ptr(dynamic_cast(&if0D)); + } else if (typeid(if0D) == typeid(NonTVertex)) { + return BPy_NonTVertex_from_NonTVertex_ptr(dynamic_cast(&if0D)); + } else if (typeid(if0D) == typeid(TVertex)) { + return BPy_TVertex_from_TVertex_ptr(dynamic_cast(&if0D)); + } else { + cerr << "Warning: cast to " << if0D.getExactTypeName() << " not implemented" << endl; + return BPy_Interface0D_from_Interface0D(if0D); + } } -- cgit v1.2.3