source/blender/freestyle/intern/python/BPy_StrokeAttribute.cpp

   1 #include "BPy_StrokeAttribute.h"
   2
   3 #include "BPy_Convert.h"
   4
   5 #ifdef __cplusplus
   6 extern "C" {
   7 #endif
   8
   9 ///////////////////////////////////////////////////////////////////////////////////////////
  10
  11 /*---------------  Python API function prototypes for StrokeAttribute instance  -----------*/
  12 static int StrokeAttribute___init__(BPy_StrokeAttribute *self, PyObject *args, PyObject *kwds);
  13 static void StrokeAttribute___dealloc__(BPy_StrokeAttribute *self);
  14 static PyObject * StrokeAttribute___repr__(BPy_StrokeAttribute *self);
  15
  16 static PyObject * StrokeAttribute_getColorR( BPy_StrokeAttribute *self );
  17 static PyObject * StrokeAttribute_getColorG( BPy_StrokeAttribute *self );
  18 static PyObject * StrokeAttribute_getColorB( BPy_StrokeAttribute *self );
  19 static PyObject * StrokeAttribute_getColorRGB( BPy_StrokeAttribute *self );
  20 static PyObject * StrokeAttribute_getAlpha( BPy_StrokeAttribute *self );
  21 static PyObject * StrokeAttribute_getThicknessR( BPy_StrokeAttribute *self );
  22 static PyObject * StrokeAttribute_getThicknessL( BPy_StrokeAttribute *self );
  23 static PyObject * StrokeAttribute_getThicknessRL( BPy_StrokeAttribute *self );
  24 static PyObject * StrokeAttribute_isVisible( BPy_StrokeAttribute *self );
  25 static PyObject * StrokeAttribute_getAttributeReal( BPy_StrokeAttribute *self, PyObject *args );
  26 static PyObject * StrokeAttribute_getAttributeVec2f( BPy_StrokeAttribute *self, PyObject *args );
  27 static PyObject * StrokeAttribute_getAttributeVec3f( BPy_StrokeAttribute *self, PyObject *args );
  28 static PyObject * StrokeAttribute_isAttributeAvailableReal( BPy_StrokeAttribute *self, PyObject *args );
  29 static PyObject * StrokeAttribute_isAttributeAvailableVec2f( BPy_StrokeAttribute *self, PyObject *args );
  30 static PyObject * StrokeAttribute_isAttributeAvailableVec3f( BPy_StrokeAttribute *self, PyObject *args );
  31 static PyObject * StrokeAttribute_setColor( BPy_StrokeAttribute *self, PyObject *args );
  32 static PyObject * StrokeAttribute_setAlpha( BPy_StrokeAttribute *self, PyObject *args );
  33 static PyObject * StrokeAttribute_setThickness( BPy_StrokeAttribute *self, PyObject *args );
  34 static PyObject * StrokeAttribute_setVisible( BPy_StrokeAttribute *self, PyObject *args );
  35 static PyObject * StrokeAttribute_setAttributeReal( BPy_StrokeAttribute *self, PyObject *args );
  36 static PyObject * StrokeAttribute_setAttributeVec2f( BPy_StrokeAttribute *self, PyObject *args );
  37 static PyObject * StrokeAttribute_setAttributeVec3f( BPy_StrokeAttribute *self, PyObject *args );
  38
  39
  40 /*----------------------StrokeAttribute instance definitions ----------------------------*/
  41 static PyMethodDef BPy_StrokeAttribute_methods[] = {
  42         {"getColorR", ( PyCFunction ) StrokeAttribute_getColorR, METH_NOARGS, "Returns the R color component. "},
  43         {"getColorG", ( PyCFunction ) StrokeAttribute_getColorG, METH_NOARGS, "Returns the G color component. "},
  44         {"getColorB", ( PyCFunction ) StrokeAttribute_getColorB, METH_NOARGS, "Returns the B color component. "},
  45         {"getColorRGB", ( PyCFunction ) StrokeAttribute_getColorRGB, METH_NOARGS, "Returns the RGB color components."},
  46         {"getAlpha", ( PyCFunction ) StrokeAttribute_getAlpha, METH_NOARGS, "Returns the alpha color component."},
  47         {"getThicknessR", ( PyCFunction ) StrokeAttribute_getThicknessR, METH_NOARGS, "Returns the thickness on the right of the vertex when following the stroke. "},
  48         {"getThicknessL", ( PyCFunction ) StrokeAttribute_getThicknessL, METH_NOARGS, "Returns the thickness on the left of the vertex when following the stroke."},
  49         {"getThicknessRL", ( PyCFunction ) StrokeAttribute_getThicknessRL, METH_NOARGS, "Returns the thickness on the right and on the left of the vertex when following the stroke. "},
  50         {"isVisible", ( PyCFunction ) StrokeAttribute_isVisible, METH_NOARGS, "Returns true if the strokevertex is visible, false otherwise"},
  51         {"getAttributeReal", ( PyCFunction ) StrokeAttribute_getAttributeReal, METH_VARARGS, "(name) Returns an attribute of type real specified by name."},
  52         {"getAttributeVec2f", ( PyCFunction ) StrokeAttribute_getAttributeVec2f, METH_VARARGS, "(name) Returns an attribute of type Vec2f specified by name."},
  53         {"getAttributeVec3f", ( PyCFunction ) StrokeAttribute_getAttributeVec3f, METH_VARARGS, "(name) Returns an attribute of type Vec3f specified by name."},
  54         {"isAttributeAvailableReal", ( PyCFunction ) StrokeAttribute_isAttributeAvailableReal, METH_VARARGS, "(name) Checks whether the real attribute specified by name is available"},
  55         {"isAttributeAvailableVec2f", ( PyCFunction ) StrokeAttribute_isAttributeAvailableVec2f, METH_VARARGS, "(name) Checks whether the Vec2f attribute specified by name is available"},
  56         {"isAttributeAvailableVec3f", ( PyCFunction ) StrokeAttribute_isAttributeAvailableVec3f, METH_VARARGS, "(name) Checks whether the Vec3f attribute specified by name is available"},
  57         {"setColor", ( PyCFunction ) StrokeAttribute_setColor, METH_VARARGS, "(float a)Sets the attribute's alpha value. "},
  58         {"setAlpha", ( PyCFunction ) StrokeAttribute_setAlpha, METH_VARARGS, "(float a) Sets the attribute's alpha value."},
  59         {"setThickness", ( PyCFunction ) StrokeAttribute_setThickness, METH_VARARGS, ""},
  60         {"setVisible", ( PyCFunction ) StrokeAttribute_setVisible, METH_VARARGS, ""},
  61         {"setAttributeReal", ( PyCFunction ) StrokeAttribute_setAttributeReal, METH_VARARGS, "(name, float att) Adds a user defined attribute of type real. If there is no attribute of specified by name, it is added. Otherwise, the new value replaces the old one."},
  62         {"setAttributeVec2f", ( PyCFunction ) StrokeAttribute_setAttributeVec2f, METH_VARARGS, "(name, float att) Adds a user defined attribute of type Vec2f. If there is no attribute of specified by name, it is added. Otherwise, the new value replaces the old one."},
  63         {"setAttributeVec3f", ( PyCFunction ) StrokeAttribute_setAttributeVec3f, METH_VARARGS, "(name, float att) Adds a user defined attribute of type Vec4f. If there is no attribute of specified by name, it is added. Otherwise, the new value replaces the old one."},
  64         {NULL, NULL, 0, NULL}
  65 };
  66
  67
  68
  69 /*-----------------------BPy_StrokeAttribute type definition ------------------------------*/
  70
  71 PyTypeObject StrokeAttribute_Type = {
  72         PyVarObject_HEAD_INIT(NULL, 0)
  73         "StrokeAttribute",              /* tp_name */
  74         sizeof(BPy_StrokeAttribute),    /* tp_basicsize */
  75         0,                              /* tp_itemsize */
  76         (destructor)StrokeAttribute___dealloc__, /* tp_dealloc */
  77         0,                              /* tp_print */
  78         0,                              /* tp_getattr */
  79         0,                              /* tp_setattr */
  80         0,                              /* tp_reserved */
  81         (reprfunc)StrokeAttribute___repr__, /* tp_repr */
  82         0,                              /* tp_as_number */
  83         0,                              /* tp_as_sequence */
  84         0,                              /* tp_as_mapping */
  85         0,                              /* tp_hash  */
  86         0,                              /* tp_call */
  87         0,                              /* tp_str */
  88         0,                              /* tp_getattro */
  89         0,                              /* tp_setattro */
  90         0,                              /* tp_as_buffer */
  91         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
  92         "StrokeAttribute objects",      /* tp_doc */
  93         0,                              /* tp_traverse */
  94         0,                              /* tp_clear */
  95         0,                              /* tp_richcompare */
  96         0,                              /* tp_weaklistoffset */
  97         0,                              /* tp_iter */
  98         0,                              /* tp_iternext */
  99         BPy_StrokeAttribute_methods,    /* tp_methods */
 100         0,                              /* tp_members */
 101         0,                              /* tp_getset */
 102         0,                              /* tp_base */
 103         0,                              /* tp_dict */
 104         0,                              /* tp_descr_get */
 105         0,                              /* tp_descr_set */
 106         0,                              /* tp_dictoffset */
 107         (initproc)StrokeAttribute___init__, /* tp_init */
 108         0,                              /* tp_alloc */
 109         PyType_GenericNew,              /* tp_new */
 110 };
 111
 112 //-------------------MODULE INITIALIZATION--------------------------------
 113 int StrokeAttribute_Init( PyObject *module )
 114 {
 115         if( module == NULL )
 116                 return -1;
 117
 118         if( PyType_Ready( &StrokeAttribute_Type ) < 0 )
 119                 return -1;
 120         Py_INCREF( &StrokeAttribute_Type );
 121         PyModule_AddObject(module, "StrokeAttribute", (PyObject *)&StrokeAttribute_Type);
 122         return 0;
 123 }
 124
 125 //------------------------INSTANCE METHODS ----------------------------------
 126
 127 int StrokeAttribute___init__(BPy_StrokeAttribute *self, PyObject *args, PyObject *kwds)
 128 {
 129
 130         PyObject *obj1 = 0, *obj2 = 0 , *obj3 = 0, *obj4 = 0, *obj5 = 0 , *obj6 = 0;
 131
 132     if (! PyArg_ParseTuple(args, "|OOOOOO", &obj1, &obj2, &obj3, &obj4, &obj5, &obj6) )
 133         return -1;
 134
 135         if( !obj1 || !obj2 || !obj3 ){
 136
 137                 self->sa = new StrokeAttribute();
 138
 139         } else if(      BPy_StrokeAttribute_Check(obj1) &&
 140                                 BPy_StrokeAttribute_Check(obj2) &&
 141                                 PyFloat_Check(obj3) ) {
 142
 143                         self->sa = new StrokeAttribute( *( ((BPy_StrokeAttribute *) obj1)->sa ),
 144                                                                                         *( ((BPy_StrokeAttribute *) obj2)->sa ),
 145                                                                                         PyFloat_AsDouble( obj3 ) );
 146
 147         } else if(      obj4 && obj5 && obj6 ) {
 148
 149                         self->sa = new StrokeAttribute( PyFloat_AsDouble( obj1 ),
 150                                                                                         PyFloat_AsDouble( obj2 ),
 151                                                                                         PyFloat_AsDouble( obj3 ),
 152                                                                                         PyFloat_AsDouble( obj4 ),
 153                                                                                         PyFloat_AsDouble( obj5 ),
 154                                                                                         PyFloat_AsDouble( obj6 ) );
 155
 156         } else {
 157                 PyErr_SetString(PyExc_TypeError, "invalid arguments");
 158                 return -1;
 159         }
 160
 161         self->borrowed = 0;
 162
 163         return 0;
 164
 165 }
 166
 167 void StrokeAttribute___dealloc__(BPy_StrokeAttribute* self)
 168 {
 169         if( self->sa && !self->borrowed )
 170                 delete self->sa;
 171     Py_TYPE(self)->tp_free((PyObject*)self);
 172 }
 173
 174 PyObject * StrokeAttribute___repr__(BPy_StrokeAttribute* self)
 175 {
 176         stringstream repr("StrokeAttribute:");
 177         repr << " r: " << self->sa->getColorR()
 178                  << " g: " << self->sa->getColorG()
 179                  << " b: " << self->sa->getColorB()
 180                  << " a: " << self->sa->getAlpha()
 181                  << " - R: " << self->sa->getThicknessR()
 182                  << " L: " << self->sa->getThicknessL();
 183
 184         return PyUnicode_FromFormat( repr.str().c_str() );
 185 }
 186
 187
 188 PyObject *StrokeAttribute_getColorR( BPy_StrokeAttribute *self ) {
 189         return PyFloat_FromDouble( self->sa->getColorR() );
 190 }
 191
 192 PyObject *StrokeAttribute_getColorG( BPy_StrokeAttribute *self ) {
 193         return PyFloat_FromDouble( self->sa->getColorG() );
 194 }
 195
 196 PyObject *StrokeAttribute_getColorB( BPy_StrokeAttribute *self ) {
 197         return PyFloat_FromDouble( self->sa->getColorB() );
 198 }
 199
 200 PyObject *StrokeAttribute_getColorRGB( BPy_StrokeAttribute *self ) {
 201         Vec3f v( self->sa->getColorRGB() );
 202         return Vector_from_Vec3f( v );
 203 }
 204
 205 PyObject *StrokeAttribute_getAlpha( BPy_StrokeAttribute *self ) {
 206         return PyFloat_FromDouble( self->sa->getAlpha() );
 207 }
 208
 209 PyObject *StrokeAttribute_getThicknessR( BPy_StrokeAttribute *self ) {
 210         return PyFloat_FromDouble( self->sa->getThicknessR() );
 211 }
 212 PyObject *StrokeAttribute_getThicknessL( BPy_StrokeAttribute *self ) {
 213         return PyFloat_FromDouble( self->sa->getThicknessL() );
 214 }
 215 PyObject *StrokeAttribute_getThicknessRL( BPy_StrokeAttribute *self ) {
 216         Vec2f v( self->sa->getThicknessRL() );
 217         return Vector_from_Vec2f( v );
 218 }
 219
 220 PyObject *StrokeAttribute_isVisible( BPy_StrokeAttribute *self ) {
 221         return PyBool_from_bool( self->sa->isVisible() );
 222 }
 223
 224
 225 PyObject *StrokeAttribute_getAttributeReal( BPy_StrokeAttribute *self, PyObject *args ) {
 226         char *attr;
 227
 228         if(!( PyArg_ParseTuple(args, "s", &attr) ))
 229                 return NULL;
 230
 231         double a = self->sa->getAttributeReal( attr );
 232         return PyFloat_FromDouble( a );
 233 }
 234
 235 PyObject *StrokeAttribute_getAttributeVec2f( BPy_StrokeAttribute *self, PyObject *args ) {
 236         char *attr;
 237
 238         if(!( PyArg_ParseTuple(args, "s", &attr) ))
 239                 return NULL;
 240
 241         Vec2f a = self->sa->getAttributeVec2f( attr );
 242         return Vector_from_Vec2f( a );
 243 }
 244
 245
 246 PyObject *StrokeAttribute_getAttributeVec3f( BPy_StrokeAttribute *self, PyObject *args ) {
 247         char *attr;
 248
 249         if(!( PyArg_ParseTuple(args, "s", &attr) ))
 250                 return NULL;
 251
 252         Vec3f a = self->sa->getAttributeVec3f( attr );
 253         return Vector_from_Vec3f( a );
 254 }
 255
 256 PyObject *StrokeAttribute_isAttributeAvailableReal( BPy_StrokeAttribute *self, PyObject *args ) {
 257         char *attr;
 258
 259         if(!( PyArg_ParseTuple(args, "s", &attr) ))
 260                 return NULL;
 261
 262         return PyBool_from_bool( self->sa->isAttributeAvailableReal( attr ) );
 263 }
 264
 265 PyObject *StrokeAttribute_isAttributeAvailableVec2f( BPy_StrokeAttribute *self, PyObject *args ) {
 266         char *attr;
 267
 268         if(!( PyArg_ParseTuple(args, "s", &attr) ))
 269                 return NULL;
 270
 271         return PyBool_from_bool( self->sa->isAttributeAvailableVec2f( attr ) );
 272 }
 273
 274 PyObject *StrokeAttribute_isAttributeAvailableVec3f( BPy_StrokeAttribute *self, PyObject *args ) {
 275         char *attr;
 276
 277         if(!( PyArg_ParseTuple(args, "s", &attr) ))
 278                 return NULL;
 279
 280         return PyBool_from_bool( self->sa->isAttributeAvailableVec3f( attr ) );
 281 }
 282
 283
 284 PyObject * StrokeAttribute_setColor( BPy_StrokeAttribute *self, PyObject *args ) {
 285         PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0 ;
 286
 287         if(!( PyArg_ParseTuple(args, "O|OO", &obj1, &obj2, &obj3) ))
 288                 return NULL;
 289
 290         if( obj1 && !obj2 && !obj3 ){
 291
 292                 Vec3f *v = Vec3f_ptr_from_PyObject(obj1);
 293                 if( !v ) {
 294                         PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)");
 295                         return NULL;
 296                 }
 297                 self->sa->setColor( *v );
 298                 delete v;
 299
 300         } else if(      obj1 && obj2 && obj3 ){
 301
 302                 self->sa->setColor(     PyFloat_AsDouble(obj1),
 303                                                         PyFloat_AsDouble(obj2),
 304                                                         PyFloat_AsDouble(obj3) );
 305
 306         } else {
 307                 PyErr_SetString(PyExc_TypeError, "invalid arguments");
 308                 return NULL;
 309         }
 310
 311         Py_RETURN_NONE;
 312 }
 313
 314 PyObject * StrokeAttribute_setAlpha( BPy_StrokeAttribute *self, PyObject *args ){
 315         float f = 0;
 316
 317         if(!( PyArg_ParseTuple(args, "f", &f) ))
 318                 return NULL;
 319
 320         self->sa->setAlpha( f );
 321         Py_RETURN_NONE;
 322 }
 323
 324 PyObject * StrokeAttribute_setThickness( BPy_StrokeAttribute *self, PyObject *args )  {
 325         PyObject *obj1 = 0, *obj2 = 0;
 326
 327         if(!( PyArg_ParseTuple(args, "O|O", &obj1, &obj2) ))
 328                 return NULL;
 329
 330         if( obj1 && !obj2 ){
 331
 332                 Vec2f *v = Vec2f_ptr_from_PyObject(obj1);
 333                 if( !v ) {
 334                         PyErr_SetString(PyExc_TypeError, "argument 1 must be a 2D vector (either a list of 2 elements or Vector)");
 335                         return NULL;
 336                 }
 337                 self->sa->setThickness( *v );
 338                 delete v;
 339
 340         } else if(      obj1 && obj2 ){
 341
 342                 self->sa->setThickness( PyFloat_AsDouble(obj1),
 343                                                                 PyFloat_AsDouble(obj2) );
 344
 345         } else {
 346                 PyErr_SetString(PyExc_TypeError, "invalid arguments");
 347                 return NULL;
 348         }
 349
 350         Py_RETURN_NONE;
 351 }
 352
 353 PyObject * StrokeAttribute_setVisible( BPy_StrokeAttribute *self, PyObject *args ) {
 354         PyObject *py_b;
 355
 356         if(!( PyArg_ParseTuple(args, "O", &py_b) ))
 357                 return NULL;
 358
 359         self->sa->setVisible( bool_from_PyBool(py_b) );
 360
 361         Py_RETURN_NONE;
 362 }
 363
 364
 365 PyObject * StrokeAttribute_setAttributeReal( BPy_StrokeAttribute *self, PyObject *args ) {
 366         char *s = 0;
 367         double d = 0;
 368
 369         if(!( PyArg_ParseTuple(args, "sd", &s, &d) ))
 370                 return NULL;
 371
 372         self->sa->setAttributeReal( s, d );
 373         Py_RETURN_NONE;
 374 }
 375
 376 PyObject * StrokeAttribute_setAttributeVec2f( BPy_StrokeAttribute *self, PyObject *args ) {
 377         char *s;
 378         PyObject *obj = 0;
 379
 380         if(!( PyArg_ParseTuple(args, "sO", &s, &obj) ))
 381                 return NULL;
 382         Vec2f *v = Vec2f_ptr_from_PyObject(obj);
 383         if( !v ) {
 384                 PyErr_SetString(PyExc_TypeError, "argument 2 must be a 2D vector (either a list of 2 elements or Vector)");
 385                 return NULL;
 386         }
 387         self->sa->setAttributeVec2f( s, *v );
 388         delete v;
 389
 390         Py_RETURN_NONE;
 391 }
 392
 393 PyObject * StrokeAttribute_setAttributeVec3f( BPy_StrokeAttribute *self, PyObject *args ) {
 394         char *s;
 395         PyObject *obj = 0;
 396
 397         if(!( PyArg_ParseTuple(args, "sO", &s, &obj) ))
 398                 return NULL;
 399         Vec3f *v = Vec3f_ptr_from_PyObject(obj);
 400         if( !v ) {
 401                 PyErr_SetString(PyExc_TypeError, "argument 2 must be a 3D vector (either a list of 3 elements or Vector)");
 402                 return NULL;
 403         }
 404         self->sa->setAttributeVec3f( s, *v );
 405         delete v;
 406
 407         Py_RETURN_NONE;
 408 }
 409
 410 ///////////////////////////////////////////////////////////////////////////////////////////
 411
 412 #ifdef __cplusplus
 413 }
 414 #endif
 415