From b7bf9bf1b721ba9a1a5414179763c35a7557ccef Mon Sep 17 00:00:00 2001 From: Willian Padovani Germano Date: Wed, 28 May 2003 04:36:18 +0000 Subject: [PATCH] * Added submodule Blender.Material * Added submodule Blender.Types: Blender Type definitions can't be static anymore. * Some cleanup of now unused defines in Camera.h and Lamp.h --- source/blender/python/api2_2x/BGL.c | 4 +- source/blender/python/api2_2x/BGL.h | 28 +- source/blender/python/api2_2x/Blender.c | 250 ++--- source/blender/python/api2_2x/Camera.h | 10 +- source/blender/python/api2_2x/Image.h | 2 +- source/blender/python/api2_2x/Lamp.c | 176 ++-- source/blender/python/api2_2x/Lamp.h | 24 +- source/blender/python/api2_2x/Material.c | 1032 +++++++++++++++++++++ source/blender/python/api2_2x/Material.h | 360 +++++++ source/blender/python/api2_2x/Object.c | 12 +- source/blender/python/api2_2x/Object.h | 2 +- source/blender/python/api2_2x/Text.h | 2 +- source/blender/python/api2_2x/Types.c | 74 ++ source/blender/python/api2_2x/Types.h | 50 + source/blender/python/api2_2x/constant.c | 5 +- source/blender/python/api2_2x/constant.h | 3 +- source/blender/python/api2_2x/gen_utils.h | 8 +- source/blender/python/api2_2x/modules.h | 6 + source/blender/python/api2_2x/rgbTuple.c | 2 +- source/blender/python/api2_2x/vector.c | 6 +- 20 files changed, 1792 insertions(+), 264 deletions(-) create mode 100644 source/blender/python/api2_2x/Material.c create mode 100644 source/blender/python/api2_2x/Material.h create mode 100644 source/blender/python/api2_2x/Types.c create mode 100644 source/blender/python/api2_2x/Types.h diff --git a/source/blender/python/api2_2x/BGL.c b/source/blender/python/api2_2x/BGL.c index 06eef3c0a0d..0f45770c4c8 100644 --- a/source/blender/python/api2_2x/BGL.c +++ b/source/blender/python/api2_2x/BGL.c @@ -64,7 +64,7 @@ static Buffer *make_buffer(int type, int ndimensions, int *dimensions) buf= MEM_mallocN(length*size, "Buffer buffer"); - buffer= (Buffer *) PyObject_NEW(Buffer, &Buffer_Type); + buffer= (Buffer *) PyObject_NEW(Buffer, &buffer_Type); buffer->parent= NULL; buffer->ndimensions= ndimensions; buffer->dimensions= dimensions; @@ -170,7 +170,7 @@ static PyObject *Buffer_item(PyObject *self, int i) } size= type_size(buf->type); - newbuf= (Buffer *) PyObject_NEW(Buffer, &Buffer_Type); + newbuf= (Buffer *) PyObject_NEW(Buffer, &buffer_Type); Py_INCREF(self); newbuf->parent= self; diff --git a/source/blender/python/api2_2x/BGL.h b/source/blender/python/api2_2x/BGL.h index c63cacb2ec0..8def0e78f8e 100644 --- a/source/blender/python/api2_2x/BGL.h +++ b/source/blender/python/api2_2x/BGL.h @@ -135,7 +135,7 @@ static PyObject *Buffer_dimensions(PyObject *self); static PyObject *Buffer_getattr(PyObject *self, char *name); static PyObject *Buffer_repr(PyObject *self); -PyTypeObject Buffer_Type = { +PyTypeObject buffer_Type = { PyObject_HEAD_INIT(&PyType_Type) 0, /*ob_size*/ "Buffer", /*tp_name*/ @@ -179,7 +179,7 @@ PyTypeObject Buffer_Type = { #define buffer_str "O!" #define buffer_var(number) (bgl_buffer##number)->buf.asvoid -#define buffer_ref(number) &Buffer_Type, &bgl_buffer##number +#define buffer_ref(number) &buffer_Type, &bgl_buffer##number #define buffer_def(number) Buffer *bgl_buffer##number /* GL Pointer fields, handled by buffer type */ @@ -187,62 +187,62 @@ PyTypeObject Buffer_Type = { #define GLbooleanP_str "O!" #define GLbooleanP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLbooleanP_ref(number) &Buffer_Type, &bgl_buffer##number +#define GLbooleanP_ref(number) &buffer_Type, &bgl_buffer##number #define GLbooleanP_def(number) Buffer *bgl_buffer##number #define GLbyteP_str "O!" #define GLbyteP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLbyteP_ref(number) &Buffer_Type, &bgl_buffer##number +#define GLbyteP_ref(number) &buffer_Type, &bgl_buffer##number #define GLbyteP_def(number) Buffer *bgl_buffer##number #define GLubyteP_str "O!" #define GLubyteP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLubyteP_ref(number) &Buffer_Type, &bgl_buffer##number +#define GLubyteP_ref(number) &buffer_Type, &bgl_buffer##number #define GLubyteP_def(number) Buffer *bgl_buffer##number #define GLintP_str "O!" #define GLintP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLintP_ref(number) &Buffer_Type, &bgl_buffer##number +#define GLintP_ref(number) &buffer_Type, &bgl_buffer##number #define GLintP_def(number) Buffer *bgl_buffer##number #define GLuintP_str "O!" #define GLuintP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLuintP_ref(number) &Buffer_Type, &bgl_buffer##number +#define GLuintP_ref(number) &buffer_Type, &bgl_buffer##number #define GLuintP_def(number) Buffer *bgl_buffer##number #define GLshortP_str "O!" #define GLshortP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLshortP_ref(number) &Buffer_Type, &bgl_buffer##number +#define GLshortP_ref(number) &buffer_Type, &bgl_buffer##number #define GLshortP_def(number) Buffer *bgl_buffer##number #define GLushortP_str "O!" #define GLushortP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLushortP_ref(number) &Buffer_Type, &bgl_buffer##number +#define GLushortP_ref(number) &buffer_Type, &bgl_buffer##number #define GLushortP_def(number) Buffer *bgl_buffer##number #define GLfloatP_str "O!" #define GLfloatP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLfloatP_ref(number) &Buffer_Type, &bgl_buffer##number +#define GLfloatP_ref(number) &buffer_Type, &bgl_buffer##number #define GLfloatP_def(number) Buffer *bgl_buffer##number #define GLdoubleP_str "O!" #define GLdoubleP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLdoubleP_ref(number) &Buffer_Type, &bgl_buffer##number +#define GLdoubleP_ref(number) &buffer_Type, &bgl_buffer##number #define GLdoubleP_def(number) Buffer *bgl_buffer##number #define GLclampfP_str "O!" #define GLclampfP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLclampfP_ref(number) &Buffer_Type, &bgl_buffer##number +#define GLclampfP_ref(number) &buffer_Type, &bgl_buffer##number #define GLclampfP_def(number) Buffer *bgl_buffer##number #define GLvoidP_str "O!" #define GLvoidP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLvoidP_ref(number) &Buffer_Type, &bgl_buffer##number +#define GLvoidP_ref(number) &buffer_Type, &bgl_buffer##number #define GLvoidP_def(number) Buffer *bgl_buffer##number #define buffer_str "O!" #define buffer_var(number) (bgl_buffer##number)->buf.asvoid -#define buffer_ref(number) &Buffer_Type, &bgl_buffer##number +#define buffer_ref(number) &buffer_Type, &bgl_buffer##number #define buffer_def(number) Buffer *bgl_buffer##number /*@The standard GL typedefs are used as prototypes, we can't diff --git a/source/blender/python/api2_2x/Blender.c b/source/blender/python/api2_2x/Blender.c index 33d8223675f..bce6f5130fe 100644 --- a/source/blender/python/api2_2x/Blender.c +++ b/source/blender/python/api2_2x/Blender.c @@ -42,34 +42,34 @@ PyObject *g_blenderdict; /*****************************************************************************/ PyObject *Blender_Set (PyObject *self, PyObject *args) { - char * name; - PyObject * arg; - int framenum; - - if (!PyArg_ParseTuple(args, "sO", &name, &arg)) - { - /* TODO: Do we need to generate a nice error message here? */ - return (NULL); - } + char * name; + PyObject * arg; + int framenum; + + if (!PyArg_ParseTuple(args, "sO", &name, &arg)) + { + /* TODO: Do we need to generate a nice error message here? */ + return (NULL); + } - if (StringEqual (name, "curframe")) - { - if (!PyArg_Parse(arg, "i", &framenum)) - { - /* TODO: Do we need to generate a nice error message here? */ - return (NULL); - } + if (StringEqual (name, "curframe")) + { + if (!PyArg_Parse(arg, "i", &framenum)) + { + /* TODO: Do we need to generate a nice error message here? */ + return (NULL); + } - G.scene->r.cfra = framenum; + G.scene->r.cfra = framenum; - update_for_newframe(); - } - else - { - return (PythonReturnErrorObject (PyExc_AttributeError, - "bad request identifier")); - } - return ( PythonIncRef (Py_None) ); + update_for_newframe(); + } + else + { + return (PythonReturnErrorObject (PyExc_AttributeError, + "bad request identifier")); + } + return ( PythonIncRef (Py_None) ); } /*****************************************************************************/ @@ -78,79 +78,79 @@ PyObject *Blender_Set (PyObject *self, PyObject *args) /*****************************************************************************/ PyObject *Blender_Get (PyObject *self, PyObject *args) { - PyObject * object; - PyObject * dict; - char * str; - - printf ("In Blender_Get()\n"); + PyObject * object; + PyObject * dict; + char * str; + + printf ("In Blender_Get()\n"); - if (!PyArg_ParseTuple (args, "O", &object)) - { - /* TODO: Do we need to generate a nice error message here? */ - return (NULL); - } + if (!PyArg_ParseTuple (args, "O", &object)) + { + /* TODO: Do we need to generate a nice error message here? */ + return (NULL); + } - if (PyString_Check (object)) - { - str = PyString_AsString (object); + if (PyString_Check (object)) + { + str = PyString_AsString (object); - if (StringEqual (str, "curframe")) - { - return ( PyInt_FromLong (G.scene->r.cfra) ); - } - if (StringEqual (str, "curtime")) - { - return ( PyFloat_FromDouble (frame_to_float (G.scene->r.cfra) ) ); - } - if (StringEqual (str, "staframe")) - { - return ( PyInt_FromLong (G.scene->r.sfra) ); - } - if (StringEqual (str, "endframe")) - { - return ( PyInt_FromLong (G.scene->r.efra) ); - } - if (StringEqual (str, "filename")) - { - return ( PyString_FromString (G.sce) ); - } - /* According to the old file (opy_blender.c), the following if - statement is a quick hack and needs some clean up. */ - if (StringEqual (str, "vrmloptions")) - { - dict = PyDict_New (); + if (StringEqual (str, "curframe")) + { + return ( PyInt_FromLong (G.scene->r.cfra) ); + } + if (StringEqual (str, "curtime")) + { + return ( PyFloat_FromDouble (frame_to_float (G.scene->r.cfra) ) ); + } + if (StringEqual (str, "staframe")) + { + return ( PyInt_FromLong (G.scene->r.sfra) ); + } + if (StringEqual (str, "endframe")) + { + return ( PyInt_FromLong (G.scene->r.efra) ); + } + if (StringEqual (str, "filename")) + { + return ( PyString_FromString (G.sce) ); + } + /* According to the old file (opy_blender.c), the following if + statement is a quick hack and needs some clean up. */ + if (StringEqual (str, "vrmloptions")) + { + dict = PyDict_New (); - PyDict_SetItemString (dict, "twoside", - PyInt_FromLong (U.vrmlflag & USERDEF_VRML_TWOSIDED)); + PyDict_SetItemString (dict, "twoside", + PyInt_FromLong (U.vrmlflag & USERDEF_VRML_TWOSIDED)); - PyDict_SetItemString (dict, "layers", - PyInt_FromLong (U.vrmlflag & USERDEF_VRML_LAYERS)); + PyDict_SetItemString (dict, "layers", + PyInt_FromLong (U.vrmlflag & USERDEF_VRML_LAYERS)); - PyDict_SetItemString (dict, "autoscale", - PyInt_FromLong (U.vrmlflag & USERDEF_VRML_AUTOSCALE)); + PyDict_SetItemString (dict, "autoscale", + PyInt_FromLong (U.vrmlflag & USERDEF_VRML_AUTOSCALE)); - return (dict); - } /* End 'quick hack' part. */ - if (StringEqual (str, "version")) - { - return ( PyInt_FromLong (G.version) ); - } - /* TODO: Do we want to display a usefull message here that the - requested data is unknown? - else - { - return (PythonReturnErrorObject (..., "message") ); - } - */ - } - else - { - return (PythonReturnErrorObject (PyExc_AttributeError, - "expected string argument")); - } + return (dict); + } /* End 'quick hack' part. */ + if (StringEqual (str, "version")) + { + return ( PyInt_FromLong (G.version) ); + } + /* TODO: Do we want to display a usefull message here that the + requested data is unknown? + else + { + return (PythonReturnErrorObject (..., "message") ); + } + */ + } + else + { + return (PythonReturnErrorObject (PyExc_AttributeError, + "expected string argument")); + } - return (PythonReturnErrorObject (PyExc_AttributeError, - "bad request identifier")); + return (PythonReturnErrorObject (PyExc_AttributeError, + "bad request identifier")); } /*****************************************************************************/ @@ -160,17 +160,17 @@ PyObject *Blender_Get (PyObject *self, PyObject *args) PyObject *Blender_Redraw(PyObject *self, PyObject *args) { - int wintype = SPACE_VIEW3D; + int wintype = SPACE_VIEW3D; - printf ("In Blender_Redraw()\n"); + printf ("In Blender_Redraw()\n"); - if (!PyArg_ParseTuple (args, "|i", &wintype)) - { - return EXPP_ReturnPyObjError (PyExc_TypeError, - "expected int argument (or nothing)"); - } + if (!PyArg_ParseTuple (args, "|i", &wintype)) + { + return EXPP_ReturnPyObjError (PyExc_TypeError, + "expected int argument (or nothing)"); + } - return M_Window_Redraw(self, Py_BuildValue("(i)", wintype)); + return M_Window_Redraw(self, Py_BuildValue("(i)", wintype)); } /*****************************************************************************/ @@ -187,15 +187,15 @@ PyObject *Blender_Redraw(PyObject *self, PyObject *args) /*****************************************************************************/ PyObject *Blender_ReleaseGlobalDict(PyObject *self, PyObject *args) { - printf ("In Blender_ReleaseGlobalDict()\n"); + printf ("In Blender_ReleaseGlobalDict()\n"); - if (!PyArg_ParseTuple (args, "|i", &EXPP_releaseGlobalDict)) - { - return EXPP_ReturnPyObjError (PyExc_TypeError, - "expected int argument (or nothing)"); - } + if (!PyArg_ParseTuple (args, "|i", &EXPP_releaseGlobalDict)) + { + return EXPP_ReturnPyObjError (PyExc_TypeError, + "expected int argument (or nothing)"); + } - return Py_BuildValue("i", (EXPP_releaseGlobalDict?1:0)); + return Py_BuildValue("i", (EXPP_releaseGlobalDict?1:0)); } /*****************************************************************************/ @@ -203,27 +203,29 @@ PyObject *Blender_ReleaseGlobalDict(PyObject *self, PyObject *args) /*****************************************************************************/ void M_Blender_Init (void) { - PyObject * module; - PyObject * dict; + PyObject * module; + PyObject * dict; - printf ("In M_Blender_Init()\n"); - g_blenderdict = NULL; + printf ("In M_Blender_Init()\n"); + g_blenderdict = NULL; - /* TODO: create a docstring for the Blender module */ - module = Py_InitModule3("Blender", Blender_methods, NULL); + /* TODO: create a docstring for the Blender module */ + module = Py_InitModule3("Blender", Blender_methods, NULL); - dict = PyModule_GetDict (module); - g_blenderdict = dict; - PyDict_SetItemString (dict, "Object", M_Object_Init()); - PyDict_SetItemString (dict, "NMesh", M_NMesh_Init()); - PyDict_SetItemString (dict, "Camera", M_Camera_Init()); - PyDict_SetItemString (dict, "Lamp", M_Lamp_Init()); - PyDict_SetItemString (dict, "Curve", M_Curve_Init()); - PyDict_SetItemString (dict, "Image", M_Image_Init()); - PyDict_SetItemString (dict, "Window", M_Window_Init()); - PyDict_SetItemString (dict, "Draw", M_Draw_Init()); - PyDict_SetItemString (dict, "BGL", M_BGL_Init()); - PyDict_SetItemString (dict, "Text", M_Text_Init()); -// PyDict_SetItemString (dict, "Effect", M_Text_Init()); + dict = PyModule_GetDict (module); + g_blenderdict = dict; + PyDict_SetItemString (dict, "Object", M_Object_Init()); + PyDict_SetItemString (dict, "Types", M_Types_Init()); + PyDict_SetItemString (dict, "NMesh", M_NMesh_Init()); + PyDict_SetItemString (dict, "Material", M_Material_Init()); + PyDict_SetItemString (dict, "Camera", M_Camera_Init()); + PyDict_SetItemString (dict, "Lamp", M_Lamp_Init()); + PyDict_SetItemString (dict, "Curve", M_Curve_Init()); + PyDict_SetItemString (dict, "Image", M_Image_Init()); + PyDict_SetItemString (dict, "Window", M_Window_Init()); + PyDict_SetItemString (dict, "Draw", M_Draw_Init()); + PyDict_SetItemString (dict, "BGL", M_BGL_Init()); + PyDict_SetItemString (dict, "Text", M_Text_Init()); +/* PyDict_SetItemString (dict, "Effect", M_Effect_Init()); */ } diff --git a/source/blender/python/api2_2x/Camera.h b/source/blender/python/api2_2x/Camera.h index 419cd9f0f6d..e297d485a92 100644 --- a/source/blender/python/api2_2x/Camera.h +++ b/source/blender/python/api2_2x/Camera.h @@ -57,20 +57,14 @@ #define EXPP_CAM_MODE_SHOWLIMITS 1 #define EXPP_CAM_MODE_SHOWMIST 2 -/* Camera default and MIN, MAX values */ +/* Camera MIN, MAX values */ -#define EXPP_CAM_TYPE EXPP_CAM_TYPE_PERSP -#define EXPP_CAM_MODE 0 -#define EXPP_CAM_LENS 35.0 #define EXPP_CAM_LENS_MIN 1.0 #define EXPP_CAM_LENS_MAX 250.0 -#define EXPP_CAM_CLIPSTART 0.10 #define EXPP_CAM_CLIPSTART_MIN 0.00 #define EXPP_CAM_CLIPSTART_MAX 100.00 -#define EXPP_CAM_CLIPEND 100.0 #define EXPP_CAM_CLIPEND_MIN 1.0 #define EXPP_CAM_CLIPEND_MAX 5000.0 -#define EXPP_CAM_DRAWSIZE 0.5 #define EXPP_CAM_DRAWSIZE_MIN 0.1 #define EXPP_CAM_DRAWSIZE_MAX 10.0 @@ -207,7 +201,7 @@ int CameraCheckPyObject (PyObject *pyobj); /*****************************************************************************/ /* Python Camera_Type structure definition: */ /*****************************************************************************/ -static PyTypeObject Camera_Type = +PyTypeObject Camera_Type = { PyObject_HEAD_INIT(&PyType_Type) 0, /* ob_size */ diff --git a/source/blender/python/api2_2x/Image.h b/source/blender/python/api2_2x/Image.h index 23a8220d83f..2c725c9bc81 100644 --- a/source/blender/python/api2_2x/Image.h +++ b/source/blender/python/api2_2x/Image.h @@ -140,7 +140,7 @@ static PyObject *ImageRepr (C_Image *self); /*****************************************************************************/ /* Python Image_Type structure definition: */ /*****************************************************************************/ -static PyTypeObject Image_Type = +PyTypeObject Image_Type = { PyObject_HEAD_INIT(&PyType_Type) 0, /* ob_size */ diff --git a/source/blender/python/api2_2x/Lamp.c b/source/blender/python/api2_2x/Lamp.c index f6537280f30..15b41e3698b 100644 --- a/source/blender/python/api2_2x/Lamp.c +++ b/source/blender/python/api2_2x/Lamp.c @@ -154,18 +154,60 @@ static PyObject *M_Lamp_Get(PyObject *self, PyObject *args) } } +static PyObject *M_Lamp_TypesDict (void) +{ /* create the Blender.Lamp.Types constant dict */ + PyObject *Types = M_constant_New(); + + if (Types) { + C_constant *c = (C_constant *)Types; + + constant_insert (c, "Lamp", PyInt_FromLong (EXPP_LAMP_TYPE_LAMP)); + constant_insert (c, "Sun", PyInt_FromLong (EXPP_LAMP_TYPE_SUN)); + constant_insert (c, "Spot", PyInt_FromLong (EXPP_LAMP_TYPE_SPOT)); + constant_insert (c, "Hemi", PyInt_FromLong (EXPP_LAMP_TYPE_HEMI)); + + } + + return Types; +} + +static PyObject *M_Lamp_ModesDict (void) +{ /* create the Blender.Lamp.Modes constant dict */ + PyObject *Modes = M_constant_New(); + + if (Modes) { + C_constant *c = (C_constant *)Modes; + + constant_insert (c, "Shadows", PyInt_FromLong (EXPP_LAMP_MODE_SHADOWS)); + constant_insert (c, "Halo", PyInt_FromLong (EXPP_LAMP_MODE_HALO)); + constant_insert (c, "Layer", PyInt_FromLong (EXPP_LAMP_MODE_LAYER)); + constant_insert (c, "Quad", PyInt_FromLong (EXPP_LAMP_MODE_QUAD)); + constant_insert (c, "Negative", PyInt_FromLong (EXPP_LAMP_MODE_NEGATIVE)); + constant_insert (c, "Sphere", PyInt_FromLong (EXPP_LAMP_MODE_SPHERE)); + constant_insert (c, "Square", PyInt_FromLong (EXPP_LAMP_MODE_SQUARE)); + constant_insert (c, "OnlyShadow", + PyInt_FromLong (EXPP_LAMP_MODE_ONLYSHADOW)); + } + + return Modes; +} + /*****************************************************************************/ /* Function: M_Lamp_Init */ /*****************************************************************************/ /* Needed by the Blender module, to register the Blender.Lamp submodule */ PyObject *M_Lamp_Init (void) { - PyObject *submodule; + PyObject *submodule, *Types, *Modes; - printf ("In M_Lamp_Init()\n"); + Types = M_Lamp_TypesDict (); + Modes = M_Lamp_ModesDict (); submodule = Py_InitModule3("Blender.Lamp", M_Lamp_methods, M_Lamp_doc); + if (Types) PyModule_AddObject(submodule, "Types", Types); + if (Modes) PyModule_AddObject(submodule, "Modes", Modes); + return (submodule); } @@ -193,7 +235,7 @@ PyObject *Lamp_createPyObject (Lamp *lamp) rgb[1] = &lamp->g; rgb[2] = &lamp->b; - pylamp->color = rgbTuple_New(rgb); + pylamp->color = (C_rgbTuple *)rgbTuple_New(rgb); return (PyObject *)pylamp; } @@ -393,7 +435,7 @@ static PyObject *Lamp_getQuad2(C_Lamp *self) static PyObject *Lamp_getCol(C_Lamp *self) { - return rgbTuple_getCol((C_rgbTuple *)self->color); + return rgbTuple_getCol(self->color); } static PyObject *Lamp_setName(C_Lamp *self, PyObject *args) @@ -461,7 +503,7 @@ static PyObject *Lamp_setIntType(C_Lamp *self, PyObject *args) } static PyObject *Lamp_setMode(C_Lamp *self, PyObject *args) -{/* Quad, Sphere, Shadows, Halo, Layer, Negative, OnlyShadow, Square */ +{ char *m[8] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL}; short i, flag = 0; @@ -524,12 +566,8 @@ static PyObject *Lamp_setSamples(C_Lamp *self, PyObject *args) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument in [1,16]")); - if (value >= EXPP_LAMP_SAMPLES_MIN && - value <= EXPP_LAMP_SAMPLES_MAX) - self->lamp->samp = value; - else - return (EXPP_ReturnPyObjError (PyExc_ValueError, - "expected int argument in [1,16]")); + self->lamp->samp = EXPP_ClampInt (value, + EXPP_LAMP_SAMPLES_MIN, EXPP_LAMP_SAMPLES_MAX); Py_INCREF(Py_None); return Py_None; @@ -543,12 +581,8 @@ static PyObject *Lamp_setBufferSize(C_Lamp *self, PyObject *args) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument in [512, 5120]")); - if (value >= EXPP_LAMP_BUFFERSIZE_MIN && - value <= EXPP_LAMP_BUFFERSIZE_MAX) - self->lamp->bufsize = value; - else - return (EXPP_ReturnPyObjError (PyExc_ValueError, - "expected int argument in [512, 5120]")); + self->lamp->bufsize = EXPP_ClampInt (value, + EXPP_LAMP_BUFFERSIZE_MIN, EXPP_LAMP_BUFFERSIZE_MAX); Py_INCREF(Py_None); return Py_None; @@ -562,33 +596,8 @@ static PyObject *Lamp_setHaloStep(C_Lamp *self, PyObject *args) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument in [0,12]")); - if (value >= EXPP_LAMP_HALOSTEP_MIN && - value <= EXPP_LAMP_HALOSTEP_MAX) - self->lamp->shadhalostep = value; - else - return (EXPP_ReturnPyObjError (PyExc_ValueError, - "expected int argument in [0,12]")); - - Py_INCREF(Py_None); - return Py_None; -} - -static PyObject *Lamp_setColorComponent(C_Lamp *self, char *key, PyObject *args) -{ - float value; - - if (!PyArg_ParseTuple(args, "f", &value)) - return (EXPP_ReturnPyObjError (PyExc_TypeError, - "expected float argument in [0.0, 1.0]")); - - value = EXPP_ClampFloat (value, 0.0, 1.0); - - if (!strcmp(key, "R")) - self->lamp->r = value; - else if (!strcmp(key, "G")) - self->lamp->g = value; - else if (!strcmp(key, "B")) - self->lamp->b = value; + self->lamp->shadhalostep = EXPP_ClampInt (value, + EXPP_LAMP_HALOSTEP_MIN, EXPP_LAMP_HALOSTEP_MAX); Py_INCREF(Py_None); return Py_None; @@ -602,8 +611,8 @@ static PyObject *Lamp_setEnergy(C_Lamp *self, PyObject *args) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected float argument")); - value = EXPP_ClampFloat (value, EXPP_LAMP_ENERGY_MIN, EXPP_LAMP_ENERGY_MAX); - self->lamp->energy = value; + self->lamp->energy = EXPP_ClampFloat (value, + EXPP_LAMP_ENERGY_MIN, EXPP_LAMP_ENERGY_MAX); Py_INCREF(Py_None); return Py_None; @@ -617,8 +626,8 @@ static PyObject *Lamp_setDist(C_Lamp *self, PyObject *args) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected float argument")); - value = EXPP_ClampFloat (value, EXPP_LAMP_DIST_MIN, EXPP_LAMP_DIST_MAX); - self->lamp->dist = value; + self->lamp->dist = EXPP_ClampFloat (value, + EXPP_LAMP_DIST_MIN, EXPP_LAMP_DIST_MAX); Py_INCREF(Py_None); return Py_None; @@ -632,9 +641,8 @@ static PyObject *Lamp_setSpotSize(C_Lamp *self, PyObject *args) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected float argument")); - value = EXPP_ClampFloat (value, EXPP_LAMP_SPOTSIZE_MIN, - EXPP_LAMP_SPOTSIZE_MAX); - self->lamp->spotsize = value; + self->lamp->spotsize = EXPP_ClampFloat (value, + EXPP_LAMP_SPOTSIZE_MIN, EXPP_LAMP_SPOTSIZE_MAX); Py_INCREF(Py_None); return Py_None; @@ -648,9 +656,8 @@ static PyObject *Lamp_setSpotBlend(C_Lamp *self, PyObject *args) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected float argument")); - value = EXPP_ClampFloat (value, EXPP_LAMP_SPOTBLEND_MIN, - EXPP_LAMP_SPOTBLEND_MAX); - self->lamp->spotblend = value; + self->lamp->spotblend = EXPP_ClampFloat (value, + EXPP_LAMP_SPOTBLEND_MIN, EXPP_LAMP_SPOTBLEND_MAX); Py_INCREF(Py_None); return Py_None; @@ -664,9 +671,8 @@ static PyObject *Lamp_setClipStart(C_Lamp *self, PyObject *args) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected float argument")); - value = EXPP_ClampFloat (value, EXPP_LAMP_CLIPSTART_MIN, - EXPP_LAMP_CLIPSTART_MAX); - self->lamp->clipsta = value; + self->lamp->clipsta = EXPP_ClampFloat (value, + EXPP_LAMP_CLIPSTART_MIN, EXPP_LAMP_CLIPSTART_MAX); Py_INCREF(Py_None); return Py_None; @@ -680,9 +686,8 @@ static PyObject *Lamp_setClipEnd(C_Lamp *self, PyObject *args) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected float argument")); - value = EXPP_ClampFloat (value, EXPP_LAMP_CLIPEND_MIN, - EXPP_LAMP_CLIPEND_MAX); - self->lamp->clipend = value; + self->lamp->clipend = EXPP_ClampFloat (value, + EXPP_LAMP_CLIPEND_MIN, EXPP_LAMP_CLIPEND_MAX); Py_INCREF(Py_None); return Py_None; @@ -696,8 +701,8 @@ static PyObject *Lamp_setBias(C_Lamp *self, PyObject *args) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected float argument")); - value = EXPP_ClampFloat (value, EXPP_LAMP_BIAS_MIN, EXPP_LAMP_BIAS_MAX); - self->lamp->bias = value; + self->lamp->bias = EXPP_ClampFloat (value, + EXPP_LAMP_BIAS_MIN, EXPP_LAMP_BIAS_MAX); Py_INCREF(Py_None); return Py_None; @@ -711,9 +716,8 @@ static PyObject *Lamp_setSoftness(C_Lamp *self, PyObject *args) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected float argument")); - value = EXPP_ClampFloat (value, EXPP_LAMP_SOFTNESS_MIN, - EXPP_LAMP_SOFTNESS_MAX); - self->lamp->soft = value; + self->lamp->soft = EXPP_ClampFloat (value, + EXPP_LAMP_SOFTNESS_MIN, EXPP_LAMP_SOFTNESS_MAX); Py_INCREF(Py_None); return Py_None; @@ -727,9 +731,8 @@ static PyObject *Lamp_setHaloInt(C_Lamp *self, PyObject *args) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected float argument")); - value = EXPP_ClampFloat (value, EXPP_LAMP_HALOINT_MIN, - EXPP_LAMP_HALOINT_MAX); - self->lamp->haint = value; + self->lamp->haint = EXPP_ClampFloat (value, + EXPP_LAMP_HALOINT_MIN, EXPP_LAMP_HALOINT_MAX); Py_INCREF(Py_None); return Py_None; @@ -743,9 +746,8 @@ static PyObject *Lamp_setQuad1(C_Lamp *self, PyObject *args) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected float argument")); - value = EXPP_ClampFloat (value, EXPP_LAMP_QUAD1_MIN, - EXPP_LAMP_QUAD1_MAX); - self->lamp->att1 = value; + self->lamp->att1 = EXPP_ClampFloat (value, + EXPP_LAMP_QUAD1_MIN, EXPP_LAMP_QUAD1_MAX); Py_INCREF(Py_None); return Py_None; @@ -759,17 +761,39 @@ static PyObject *Lamp_setQuad2(C_Lamp *self, PyObject *args) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected float argument")); - value = EXPP_ClampFloat (value, EXPP_LAMP_QUAD2_MIN, - EXPP_LAMP_QUAD2_MAX); - self->lamp->att2 = value; + self->lamp->att2 = EXPP_ClampFloat (value, + EXPP_LAMP_QUAD2_MIN, EXPP_LAMP_QUAD2_MAX); Py_INCREF(Py_None); return Py_None; } +static PyObject *Lamp_setColorComponent(C_Lamp *self, char *key, + PyObject *args) +{ /* for compatibility with old bpython */ + float value; + + if (!PyArg_ParseTuple(args, "f", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected float argument in [0.0, 1.0]")); + + value = EXPP_ClampFloat (value, EXPP_LAMP_COL_MIN, + EXPP_LAMP_COL_MAX); + + if (!strcmp(key, "R")) + self->lamp->r = value; + else if (!strcmp(key, "G")) + self->lamp->g = value; + else if (!strcmp(key, "B")) + self->lamp->b = value; + + Py_INCREF(Py_None); + return Py_None; +} + static PyObject *Lamp_setCol(C_Lamp *self, PyObject *args) { - return rgbTuple_setCol((C_rgbTuple *)self->color, args); + return rgbTuple_setCol(self->color, args); } /*****************************************************************************/ @@ -811,7 +835,7 @@ static PyObject *LampGetAttr (C_Lamp *self, char *name) else if (strcmp(name, "B") == 0) attr = PyFloat_FromDouble(self->lamp->b); else if (strcmp(name, "col") == 0) - attr = EXPP_incr_ret(self->color); + attr = Lamp_getCol(self); else if (strcmp(name, "energy") == 0) attr = PyFloat_FromDouble(self->lamp->energy); else if (strcmp(name, "dist") == 0) diff --git a/source/blender/python/api2_2x/Lamp.h b/source/blender/python/api2_2x/Lamp.h index a03c464390f..36b899c908c 100644 --- a/source/blender/python/api2_2x/Lamp.h +++ b/source/blender/python/api2_2x/Lamp.h @@ -72,52 +72,38 @@ #define EXPP_LAMP_MODE_OSATEX 512 #define EXPP_LAMP_MODE_DEEPSHADOW 1024 -/* Lamp default and MIN, MAX values */ +/* Lamp MIN, MAX values */ -#define EXPP_LAMP_TYPE EXPP_LAMP_TYPE_LAMP -#define EXPP_LAMP_MODE EXPP_LAMP_MODE_SHADOWS -#define EXPP_LAMP_SAMPLES 3 #define EXPP_LAMP_SAMPLES_MIN 1 #define EXPP_LAMP_SAMPLES_MAX 16 -#define EXPP_LAMP_BUFFERSIZE 512 #define EXPP_LAMP_BUFFERSIZE_MIN 512 #define EXPP_LAMP_BUFFERSIZE_MAX 5120 -#define EXPP_LAMP_ENERGY 1.0 #define EXPP_LAMP_ENERGY_MIN 0.0 #define EXPP_LAMP_ENERGY_MAX 10.0 -#define EXPP_LAMP_DIST 20.0 #define EXPP_LAMP_DIST_MIN 0.1 #define EXPP_LAMP_DIST_MAX 5000.0 -#define EXPP_LAMP_SPOTSIZE 45.0 #define EXPP_LAMP_SPOTSIZE_MIN 1.0 #define EXPP_LAMP_SPOTSIZE_MAX 180.0 -#define EXPP_LAMP_SPOTBLEND 0.15 #define EXPP_LAMP_SPOTBLEND_MIN 0.00 #define EXPP_LAMP_SPOTBLEND_MAX 1.00 -#define EXPP_LAMP_CLIPSTART 0.5 #define EXPP_LAMP_CLIPSTART_MIN 0.1 #define EXPP_LAMP_CLIPSTART_MAX 1000.0 -#define EXPP_LAMP_CLIPEND 40.0 #define EXPP_LAMP_CLIPEND_MIN 1.0 #define EXPP_LAMP_CLIPEND_MAX 5000.0 -#define EXPP_LAMP_BIAS 1.00 #define EXPP_LAMP_BIAS_MIN 0.01 #define EXPP_LAMP_BIAS_MAX 5.00 -#define EXPP_LAMP_SOFTNESS 3.0 #define EXPP_LAMP_SOFTNESS_MIN 1.0 #define EXPP_LAMP_SOFTNESS_MAX 100.0 -#define EXPP_LAMP_HALOINT 1.0 #define EXPP_LAMP_HALOINT_MIN 0.0 #define EXPP_LAMP_HALOINT_MAX 5.0 -#define EXPP_LAMP_HALOSTEP 0 #define EXPP_LAMP_HALOSTEP_MIN 0 #define EXPP_LAMP_HALOSTEP_MAX 12 -#define EXPP_LAMP_QUAD1 0.0 #define EXPP_LAMP_QUAD1_MIN 0.0 #define EXPP_LAMP_QUAD1_MAX 1.0 -#define EXPP_LAMP_QUAD2 1.0 #define EXPP_LAMP_QUAD2_MIN 0.0 #define EXPP_LAMP_QUAD2_MAX 1.0 +#define EXPP_LAMP_COL_MIN 0.0 +#define EXPP_LAMP_COL_MAX 1.0 /*****************************************************************************/ /* Python API function prototypes for the Lamp module. */ @@ -166,7 +152,7 @@ struct PyMethodDef M_Lamp_methods[] = { typedef struct { PyObject_HEAD Lamp *lamp; - PyObject *color; + C_rgbTuple *color; } C_Lamp; @@ -315,7 +301,7 @@ int LampCheckPyObject (PyObject *pyobj); /*****************************************************************************/ /* Python TypeLamp structure definition: */ /*****************************************************************************/ -static PyTypeObject Lamp_Type = +PyTypeObject Lamp_Type = { PyObject_HEAD_INIT(&PyType_Type) 0, /* ob_size */ diff --git a/source/blender/python/api2_2x/Material.c b/source/blender/python/api2_2x/Material.c new file mode 100644 index 00000000000..152bd806c42 --- /dev/null +++ b/source/blender/python/api2_2x/Material.c @@ -0,0 +1,1032 @@ +/* + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * This is a new part of Blender. + * + * Contributor(s): Willian P. Germano + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** +*/ + +#include "Material.h" + +/*****************************************************************************/ +/* Function: M_Material_New */ +/* Python equivalent: Blender.Material.New */ +/*****************************************************************************/ +static PyObject *M_Material_New(PyObject *self, PyObject *args, PyObject *keywords) +{ + char *name = "Mat"; + static char *kwlist[] = {"name", NULL}; + C_Material *pymat; /* for Material Data object wrapper in Python */ + Material *blmat; /* for actual Material Data we create in Blender */ + char buf[21]; + + if (!PyArg_ParseTupleAndKeywords(args, keywords, "|s", kwlist, &name)) + return (EXPP_ReturnPyObjError (PyExc_AttributeError, + "expected string or nothing as argument")); + + if (strcmp(name, "Mat") != 0) /* use gave us a name ?*/ + PyOS_snprintf(buf, sizeof(buf), "%s", name); + + blmat = add_material(name); /* first create the Material Data in Blender */ + + if (blmat) /* now create the wrapper obj in Python */ + pymat = (C_Material *)Material_createPyObject (blmat); + else + return (EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't create Material Data in Blender")); + + if (pymat == NULL) + return (EXPP_ReturnPyObjError (PyExc_MemoryError, + "couldn't create Material Data object")); + + return (PyObject *)pymat; +} + +/*****************************************************************************/ +/* Function: M_Material_Get */ +/* Python equivalent: Blender.Material.Get */ +/* Description: Receives a string and returns the material whose */ +/* name matches the string. If no argument is */ +/* passed in, a list of all materials in the */ +/* current scene is returned. */ +/*****************************************************************************/ +static PyObject *M_Material_Get(PyObject *self, PyObject *args) +{ + char *name = NULL; + Material *mat_iter; + + if (!PyArg_ParseTuple(args, "|s", &name)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected string argument (or nothing)")); + + mat_iter = G.main->mat.first; + + if (name) { /* (name) - Search material by name */ + + C_Material *wanted_mat = NULL; + + while ((mat_iter) && (wanted_mat == NULL)) { + + if (strcmp (name, mat_iter->id.name+2) == 0) + wanted_mat = (C_Material *)Material_createPyObject (mat_iter); + + mat_iter = mat_iter->id.next; + } + + if (wanted_mat == NULL) { /* Requested material doesn't exist */ + char error_msg[64]; + PyOS_snprintf(error_msg, sizeof(error_msg), + "Material \"%s\" not found", name); + return (EXPP_ReturnPyObjError (PyExc_NameError, error_msg)); + } + + return (PyObject *)wanted_mat; + } + + else { /* () - return a list of all materials in the scene */ + int index = 0; + PyObject *matlist, *pystr; + + matlist = PyList_New (BLI_countlist (&(G.main->mat))); + + if (matlist == NULL) + return (PythonReturnErrorObject (PyExc_MemoryError, + "couldn't create PyList")); + + while (mat_iter) { + pystr = PyString_FromString (mat_iter->id.name+2); + + if (!pystr) + return (PythonReturnErrorObject (PyExc_MemoryError, + "couldn't create PyString")); + + PyList_SET_ITEM (matlist, index, pystr); + + mat_iter = mat_iter->id.next; + index++; + } + + return (matlist); + } +} + +/*****************************************************************************/ +/* Function: M_Material_Init */ +/*****************************************************************************/ +PyObject *M_Material_Init (void) +{ + PyObject *submodule; + + submodule = Py_InitModule3("Blender.Material", + M_Material_methods, M_Material_doc); + + return (submodule); +} + +/*****************************************************************************/ +/* Python C_Material methods: */ +/*****************************************************************************/ +static PyObject *Material_getName(C_Material *self) +{ + PyObject *attr = PyString_FromString(self->material->id.name+2); + + if (attr) return attr; + + return (EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Material.name attribute")); +} + +static PyObject *Material_getMode(C_Material *self) +{ + PyObject *attr = PyInt_FromLong((long)self->material->mode); + + if (attr) return attr; + + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Material.Mode attribute"); +} + +static PyObject *Material_getRGBCol(C_Material *self) +{ + return rgbTuple_getCol(self->rgb); +} + +static PyObject *Material_getAmbCol(C_Material *self) +{ + return rgbTuple_getCol(self->amb); +} + +static PyObject *Material_getSpecCol(C_Material *self) +{ + return rgbTuple_getCol(self->spec); +} + +static PyObject *Material_getMirCol(C_Material *self) +{ + return rgbTuple_getCol(self->mir); +} + +static PyObject *Material_getAmb(C_Material *self) +{ + PyObject *attr = PyFloat_FromDouble((double)self->material->amb); + + if (attr) return attr; + + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Material.amb attribute"); +} + +static PyObject *Material_getEmit(C_Material *self) +{ + PyObject *attr = PyFloat_FromDouble((double)self->material->emit); + + if (attr) return attr; + + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Material.emit attribute"); +} + +static PyObject *Material_getAng(C_Material *self) +{ + PyObject *attr = PyFloat_FromDouble((double)self->material->ang); + + if (attr) return attr; + + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Material.ang attribute"); +} + +static PyObject *Material_getAlpha(C_Material *self) +{ + PyObject *attr = PyFloat_FromDouble((double)self->material->alpha); + + if (attr) return attr; + + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Material.alpha attribute"); +} + +static PyObject *Material_getRef(C_Material *self) +{ + PyObject *attr = PyFloat_FromDouble((double)self->material->ref); + + if (attr) return attr; + + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Material.ref attribute"); +} + +static PyObject *Material_getSpec(C_Material *self) +{ + PyObject *attr = PyFloat_FromDouble((double)self->material->spec); + + if (attr) return attr; + + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Material.spec attribute"); +} + +static PyObject *Material_getSpecTransp(C_Material *self) +{ + PyObject *attr = PyFloat_FromDouble((double)self->material->spectra); + + if (attr) return attr; + + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Material.specTransp attribute"); +} + +static PyObject *Material_getAdd(C_Material *self) +{ + PyObject *attr = PyFloat_FromDouble((double)self->material->add); + + if (attr) return attr; + + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Material.add attribute"); +} + +static PyObject *Material_getZOffset(C_Material *self) +{ + PyObject *attr = PyFloat_FromDouble((double)self->material->zoffs); + + if (attr) return attr; + + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Material.zOffset attribute"); +} + +static PyObject *Material_getHaloSize(C_Material *self) +{ + PyObject *attr = PyFloat_FromDouble((double)self->material->hasize); + + if (attr) return attr; + + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Material.haloSize attribute"); +} + +static PyObject *Material_getFlareSize(C_Material *self) +{ + PyObject *attr = PyFloat_FromDouble((double)self->material->flaresize); + + if (attr) return attr; + + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Material.flareSize attribute"); +} + +static PyObject *Material_getFlareBoost(C_Material *self) +{ + PyObject *attr = PyFloat_FromDouble((double)self->material->flareboost); + + if (attr) return attr; + + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Material.flareBoost attribute"); +} + +static PyObject *Material_getSubSize(C_Material *self) +{ + PyObject *attr = PyFloat_FromDouble((double)self->material->subsize); + + if (attr) return attr; + + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Material.subSize attribute"); +} + +static PyObject *Material_getHardness(C_Material *self) +{ + PyObject *attr = PyInt_FromLong((long)self->material->har); + + if (attr) return attr; + + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Material.hard attribute"); +} + +static PyObject *Material_getNFlares(C_Material *self) +{ + PyObject *attr = PyInt_FromLong((long)self->material->flarec); + + if (attr) return attr; + + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Material.nFlares attribute"); +} + +static PyObject *Material_getNStars(C_Material *self) +{ + PyObject *attr = PyInt_FromLong((long)self->material->starc); + + if (attr) return attr; + + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Material.nStars attribute"); +} + +static PyObject *Material_getNLines(C_Material *self) +{ + PyObject *attr = PyInt_FromLong((long)self->material->linec); + + if (attr) return attr; + + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Material.nLines attribute"); +} + +static PyObject *Material_getNRings(C_Material *self) +{ + PyObject *attr = PyInt_FromLong((long)self->material->ringc); + + if (attr) return attr; + + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Material.nRings attribute"); +} + +static PyObject *Material_setName(C_Material *self, PyObject *args) +{ + char *name; + char buf[21]; + + if (!PyArg_ParseTuple(args, "s", &name)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected string argument")); + + PyOS_snprintf(buf, sizeof(buf), "%s", name); + + rename_id(&self->material->id, buf); + + Py_INCREF(Py_None); + return Py_None; +} + +/* Possible modes are traceable, shadow, shadeless, wire, vcolLight, + * vcolPaint, halo, ztransp, zinvert, haloRings, env, haloLines, + * onlyShadow, xalpha, star, faceTexture, haloTex, haloPuno, noMist, + * haloShade, haloFlare */ +static PyObject *Material_setMode(C_Material *self, PyObject *args) +{ + int i, flag = 0; + char *m[21] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, + NULL, NULL, NULL, NULL, NULL, NULL, NULL, + NULL, NULL, NULL, NULL, NULL, NULL, NULL}; + + if (!PyArg_ParseTuple(args, "|sssssssssssssssssssss", + &m[0], &m[1], &m[2], &m[3], &m[4], &m[5], &m[6], + &m[7], &m[8], &m[9], &m[10], &m[11], &m[12], &m[13], + &m[14], &m[15], &m[16], &m[17], &m[18], &m[19], &m[20])) + { + return (EXPP_ReturnPyObjError (PyExc_AttributeError, + "expected from none to 21 string argument(s)")); + } + + for (i = 0; i < 21; i++) { + if (m[i] == NULL) break; + if (strcmp(m[i], "Traceable") == 0) + flag |= (short)EXPP_MAT_MODE_TRACEABLE; + else if (strcmp(m[i], "Shadow") == 0) + flag |= (short)EXPP_MAT_MODE_SHADOW; + else if (strcmp(m[i], "Shadeless") == 0) + flag |= (short)EXPP_MAT_MODE_SHADELESS; + else if (strcmp(m[i], "Wire") == 0) + flag |= (short)EXPP_MAT_MODE_WIRE; + else if (strcmp(m[i], "VColLight") == 0) + flag |= (short)EXPP_MAT_MODE_VCOLLIGHT; + else if (strcmp(m[i], "VColPaint") == 0) + flag |= (short)EXPP_MAT_MODE_VCOLPAINT; + else if (strcmp(m[i], "Halo") == 0) + flag |= (short)EXPP_MAT_MODE_HALO; + else if (strcmp(m[i], "ZTransp") == 0) + flag |= (short)EXPP_MAT_MODE_ZTRANSP; + else if (strcmp(m[i], "ZInvert") == 0) + flag |= (short)EXPP_MAT_MODE_ZINVERT; + else if (strcmp(m[i], "HaloRings") == 0) + flag |= (short)EXPP_MAT_MODE_HALORINGS; + else if (strcmp(m[i], "Env") == 0) + flag |= (short)EXPP_MAT_MODE_ENV; + else if (strcmp(m[i], "HaloLines") == 0) + flag |= (short)EXPP_MAT_MODE_HALOLINES; + else if (strcmp(m[i], "OnlyShadow") == 0) + flag |= (short)EXPP_MAT_MODE_ONLYSHADOW; + else if (strcmp(m[i], "XAlpha") == 0) + flag |= (short)EXPP_MAT_MODE_XALPHA; + else if (strcmp(m[i], "Star") == 0) + flag |= (short)EXPP_MAT_MODE_STAR; + else if (strcmp(m[i], "FaceTex") == 0) + flag |= (short)EXPP_MAT_MODE_FACETEX; + else if (strcmp(m[i], "HaloTex") == 0) + flag |= (short)EXPP_MAT_MODE_HALOTEX; + else if (strcmp(m[i], "HaloPuno") == 0) + flag |= (short)EXPP_MAT_MODE_HALOPUNO; + else if (strcmp(m[i], "NoMist") == 0) + flag |= (short)EXPP_MAT_MODE_NOMIST; + else if (strcmp(m[i], "HaloShade") == 0) + flag |= (short)EXPP_MAT_MODE_HALOSHADE; + else if (strcmp(m[i], "HaloFlare") == 0) + flag |= (short)EXPP_MAT_MODE_HALOFLARE; + else + return (EXPP_ReturnPyObjError (PyExc_AttributeError, + "unknown Material mode argument")); + } + + self->material->mode = flag; + + Py_INCREF(Py_None); + return Py_None; +} + +/* Another helper function, for the same reason. + * (See comment before Material_setIntType above). */ +static PyObject *Material_setIntMode(C_Material *self, PyObject *args) +{ + int value; + + if (!PyArg_ParseTuple(args, "i", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected int argument")); + + self->material->mode = value; + + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject *Material_setRGBCol (C_Material *self, PyObject *args) +{ + return rgbTuple_setCol(self->rgb, args); +} + +static PyObject *Material_setAmbCol (C_Material *self, PyObject *args) +{ + return rgbTuple_setCol(self->amb, args); +} + +static PyObject *Material_setSpecCol (C_Material *self, PyObject *args) +{ + return rgbTuple_setCol(self->spec, args); +} + +static PyObject *Material_setMirCol (C_Material *self, PyObject *args) +{ + return rgbTuple_setCol(self->mir, args); +} + +static PyObject *Material_setColorComponent(C_Material *self, char *key, + PyObject *args) +{ /* for compatibility with old bpython */ + float value; + + if (!PyArg_ParseTuple(args, "f", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected float argument in [0.0, 1.0]")); + + value = EXPP_ClampFloat (value, EXPP_MAT_COL_MIN, + EXPP_MAT_COL_MAX); + + if (!strcmp(key, "R")) + self->material->r = value; + else if (!strcmp(key, "G")) + self->material->g = value; + else if (!strcmp(key, "B")) + self->material->b = value; + + return EXPP_incr_ret (Py_None); +} + +static PyObject *Material_setAmb(C_Material *self, PyObject *args) +{ + float value; + + if (!PyArg_ParseTuple(args, "f", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected float argument in [0.0, 1.0]")); + + self->material->amb = EXPP_ClampFloat (value, EXPP_MAT_AMB_MIN, + EXPP_MAT_AMB_MAX); + + return EXPP_incr_ret (Py_None); +} + +static PyObject *Material_setEmit(C_Material *self, PyObject *args) +{ + float value; + + if (!PyArg_ParseTuple(args, "f", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected float argument in [0.0, 1.0]")); + + self->material->emit = EXPP_ClampFloat (value, EXPP_MAT_EMIT_MIN, + EXPP_MAT_EMIT_MAX); + + return EXPP_incr_ret (Py_None); +} + +static PyObject *Material_setAng(C_Material *self, PyObject *args) +{ + float value; + + if (!PyArg_ParseTuple(args, "f", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected float argument in [0.0, 1.0]")); + + self->material->ang = EXPP_ClampFloat (value, EXPP_MAT_ANG_MIN, + EXPP_MAT_ANG_MAX); + + return EXPP_incr_ret (Py_None); +} + +static PyObject *Material_setSpecTransp(C_Material *self, PyObject *args) +{ + float value; + + if (!PyArg_ParseTuple(args, "f", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected float argument in [0.0, 1.0]")); + + self->material->spectra = EXPP_ClampFloat (value, EXPP_MAT_SPECTRA_MIN, + EXPP_MAT_SPECTRA_MAX); + + return EXPP_incr_ret (Py_None); +} + +static PyObject *Material_setAlpha(C_Material *self, PyObject *args) +{ + float value; + + if (!PyArg_ParseTuple(args, "f", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected float argument in [0.0, 1.0]")); + + self->material->alpha = EXPP_ClampFloat (value, EXPP_MAT_ALPHA_MIN, + EXPP_MAT_ALPHA_MAX); + + return EXPP_incr_ret (Py_None); +} + +static PyObject *Material_setRef(C_Material *self, PyObject *args) +{ + float value; + + if (!PyArg_ParseTuple(args, "f", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected float argument in [0.0, 1.0]")); + + self->material->ref = EXPP_ClampFloat (value, EXPP_MAT_REF_MIN, + EXPP_MAT_REF_MAX); + + return EXPP_incr_ret (Py_None); +} + +static PyObject *Material_setSpec(C_Material *self, PyObject *args) +{ + float value; + + if (!PyArg_ParseTuple(args, "f", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected float argument in [0.0, 1.0]")); + + self->material->spec = EXPP_ClampFloat (value, EXPP_MAT_SPEC_MIN, + EXPP_MAT_SPEC_MAX); + + return EXPP_incr_ret (Py_None); +} + +static PyObject *Material_setZOffset(C_Material *self, PyObject *args) +{ + float value; + + if (!PyArg_ParseTuple(args, "f", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected float argument in [0.0, 10.0]")); + + self->material->zoffs = EXPP_ClampFloat (value, EXPP_MAT_ZOFFS_MIN, + EXPP_MAT_ZOFFS_MAX); + + return EXPP_incr_ret (Py_None); +} + +static PyObject *Material_setAdd(C_Material *self, PyObject *args) +{ + float value; + + if (!PyArg_ParseTuple(args, "f", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected float argument in [0.0, 1.0]")); + + self->material->add = EXPP_ClampFloat (value, EXPP_MAT_ADD_MIN, + EXPP_MAT_ADD_MAX); + + return EXPP_incr_ret (Py_None); +} + +static PyObject *Material_setHaloSize(C_Material *self, PyObject *args) +{ + float value; + + if (!PyArg_ParseTuple(args, "f", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected float argument in [0.0, 100.0]")); + + self->material->hasize = EXPP_ClampFloat (value, EXPP_MAT_HALOSIZE_MIN, + EXPP_MAT_HALOSIZE_MAX); + + return EXPP_incr_ret (Py_None); +} + +static PyObject *Material_setFlareSize(C_Material *self, PyObject *args) +{ + float value; + + if (!PyArg_ParseTuple(args, "f", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected float argument in [0.1, 25.0]")); + + self->material->flaresize = EXPP_ClampFloat (value, EXPP_MAT_FLARESIZE_MIN, + EXPP_MAT_FLARESIZE_MAX); + + return EXPP_incr_ret (Py_None); +} + +static PyObject *Material_setFlareBoost(C_Material *self, PyObject *args) +{ + float value; + + if (!PyArg_ParseTuple(args, "f", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected float argument in [0.1, 10.0]")); + + self->material->flareboost = EXPP_ClampFloat(value, EXPP_MAT_FLAREBOOST_MIN, + EXPP_MAT_FLAREBOOST_MAX); + + return EXPP_incr_ret (Py_None); +} + +static PyObject *Material_setSubSize(C_Material *self, PyObject *args) +{ + float value; + + if (!PyArg_ParseTuple(args, "f", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected float argument in [0.1, 25.0]")); + + self->material->subsize = EXPP_ClampFloat (value, EXPP_MAT_SUBSIZE_MIN, + EXPP_MAT_SUBSIZE_MAX); + + return EXPP_incr_ret (Py_None); +} + +static PyObject *Material_setHardness(C_Material *self, PyObject *args) +{ + short value; + + if (!PyArg_ParseTuple(args, "h", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected int argument in [1, 255]")); + + self->material->har = EXPP_ClampInt (value, EXPP_MAT_HARD_MIN, + EXPP_MAT_HARD_MAX); + + return EXPP_incr_ret (Py_None); +} + +static PyObject *Material_setNFlares(C_Material *self, PyObject *args) +{ + short value; + + if (!PyArg_ParseTuple(args, "h", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected int argument in [1, 32]")); + + self->material->flarec = EXPP_ClampInt (value, EXPP_MAT_NFLARES_MIN, + EXPP_MAT_NFLARES_MAX); + + return EXPP_incr_ret (Py_None); +} + +static PyObject *Material_setNStars(C_Material *self, PyObject *args) +{ + short value; + + if (!PyArg_ParseTuple(args, "h", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected int argument in [3, 50]")); + + self->material->starc = EXPP_ClampInt (value, EXPP_MAT_NSTARS_MIN, + EXPP_MAT_NSTARS_MAX); + + return EXPP_incr_ret (Py_None); +} + +static PyObject *Material_setNLines(C_Material *self, PyObject *args) +{ + short value; + + if (!PyArg_ParseTuple(args, "h", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected int argument in [0, 250]")); + + self->material->linec = EXPP_ClampInt (value, EXPP_MAT_NLINES_MIN, + EXPP_MAT_NLINES_MAX); + + return EXPP_incr_ret (Py_None); +} + +static PyObject *Material_setNRings(C_Material *self, PyObject *args) +{ + short value; + + if (!PyArg_ParseTuple(args, "h", &value)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected int argument in [0, 24]")); + + self->material->ringc = EXPP_ClampInt (value, EXPP_MAT_NRINGS_MIN, + EXPP_MAT_NRINGS_MAX); + + return EXPP_incr_ret (Py_None); +} + +/*****************************************************************************/ +/* Function: Material_createPyObject */ +/* Description: This function will create a new C_Material from an existing */ +/* Blender material structure. */ +/*****************************************************************************/ +static PyObject *Material_createPyObject (Material *mat) +{ + C_Material *pymat; + float *rgb[3], *amb[3], *spec[3], *mir[3]; + + pymat = (C_Material *)PyObject_NEW (C_Material, &Material_Type); + + if (!pymat) + return EXPP_ReturnPyObjError (PyExc_MemoryError, + "couldn't create C_Material object"); + + pymat->material = mat; + + rgb[0] = &mat->r; + rgb[1] = &mat->g; + rgb[2] = &mat->b; + + amb[0] = &mat->ambr; + amb[1] = &mat->ambg; + amb[2] = &mat->ambb; + + spec[0] = &mat->specr; + spec[1] = &mat->specg; + spec[2] = &mat->specb; + + mir[0] = &mat->mirr; + mir[1] = &mat->mirg; + mir[2] = &mat->mirb; + + pymat->rgb = (C_rgbTuple *)rgbTuple_New(rgb); + pymat->amb = (C_rgbTuple *)rgbTuple_New(amb); + pymat->spec = (C_rgbTuple *)rgbTuple_New(spec); + pymat->mir = (C_rgbTuple *)rgbTuple_New(mir); + + return (PyObject *)pymat; +} + +/*****************************************************************************/ +/* Function: MaterialDeAlloc */ +/* Description: This is a callback function for the C_Material type. It is */ +/* the destructor function. */ +/*****************************************************************************/ +static void MaterialDeAlloc (C_Material *self) +{ + PyObject_DEL (self); +} + +/*****************************************************************************/ +/* Function: MaterialGetAttr */ +/* Description: This is a callback function for the C_Material type. It is */ +/* the function that accesses C_Material "member variables" and */ +/* methods. */ +/*****************************************************************************/ +static PyObject *MaterialGetAttr (C_Material *self, char *name) +{ + PyObject *attr = Py_None; + + if (strcmp(name, "name") == 0) + attr = PyString_FromString(self->material->id.name+2); + else if (strcmp(name, "mode") == 0) + attr = PyInt_FromLong(self->material->mode); + else if (strcmp(name, "rgbCol") == 0) + attr = Material_getRGBCol(self); + else if (strcmp(name, "ambCol") == 0) + attr = Material_getAmbCol(self); + else if (strcmp(name, "specCol") == 0) + attr = Material_getSpecCol(self); + else if (strcmp(name, "mirCol") == 0) + attr = Material_getMirCol(self); + else if (strcmp(name, "R") == 0) + attr = PyFloat_FromDouble((double)self->material->r); + else if (strcmp(name, "G") == 0) + attr = PyFloat_FromDouble((double)self->material->g); + else if (strcmp(name, "B") == 0) + attr = PyFloat_FromDouble((double)self->material->b); + else if (strcmp(name, "amb") == 0) + attr = PyFloat_FromDouble((double)self->material->amb); + else if (strcmp(name, "ang") == 0) + attr = PyFloat_FromDouble((double)self->material->ang); + else if (strcmp(name, "emit") == 0) + attr = PyFloat_FromDouble((double)self->material->emit); + else if (strcmp(name, "alpha") == 0) + attr = PyFloat_FromDouble((double)self->material->alpha); + else if (strcmp(name, "ref") == 0) + attr = PyFloat_FromDouble((double)self->material->ref); + else if (strcmp(name, "spec") == 0) + attr = PyFloat_FromDouble((double)self->material->spec); + else if (strcmp(name, "specTransp") == 0) + attr = PyFloat_FromDouble((double)self->material->spectra); + else if (strcmp(name, "add") == 0) + attr = PyFloat_FromDouble((double)self->material->add); + else if (strcmp(name, "zOffset") == 0) + attr = PyFloat_FromDouble((double)self->material->zoffs); + else if (strcmp(name, "haloSize") == 0) + attr = PyFloat_FromDouble((double)self->material->hasize); + else if (strcmp(name, "flareSize") == 0) + attr = PyFloat_FromDouble((double)self->material->flaresize); + else if (strcmp(name, "flareBoost") == 0) + attr = PyFloat_FromDouble((double)self->material->flareboost); + else if (strcmp(name, "subSize") == 0) + attr = PyFloat_FromDouble((double)self->material->subsize); + else if (strcmp(name, "hard") == 0) + attr = PyInt_FromLong((long)self->material->har); + else if (strcmp(name, "nFlares") == 0) + attr = PyInt_FromLong((long)self->material->flarec); + else if (strcmp(name, "nStars") == 0) + attr = PyInt_FromLong((long)self->material->starc); + else if (strcmp(name, "nLines") == 0) + attr = PyInt_FromLong((long)self->material->linec); + else if (strcmp(name, "nRings") == 0) + attr = PyInt_FromLong((long)self->material->ringc); + + else if (strcmp(name, "__members__") == 0) { + attr = /* 27 items */ + Py_BuildValue("[s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s]", + "name", "mode", "rgbCol", "ambCol", "specCol", "mirCol", + "R", "G", "B", "alpha", "amb", "ang", "emit", "ref", + "spec", "specTransp", "add", "zOffset", "haloSize", + "flareSize", "flareBoost", "subSize", "hard", "nFlares", + "nStars", "nLines", "nRings"); + } + + if (!attr) + return (EXPP_ReturnPyObjError (PyExc_MemoryError, + "couldn't create PyObject")); + + if (attr != Py_None) return attr; /* member attribute found, return it */ + + /* not an attribute, search the methods table */ + return Py_FindMethod(C_Material_methods, (PyObject *)self, name); +} + +/****************************************************************************/ +/* Function: MaterialSetAttr */ +/* Description: This is a callback function for the C_Material type. */ +/* It is the function that sets Material attributes (member */ +/* variables). */ +/****************************************************************************/ +static int MaterialSetAttr (C_Material *self, char *name, PyObject *value) +{ + PyObject *valtuple; + PyObject *error = NULL; + +/* We're playing a trick on the Python API users here. Even if they use + * Material.member = val instead of Material.setMember(val), we end up using the + * function anyway, since it already has error checking, clamps to the right + * interval and updates the Blender Material structure when necessary. */ + +/* First we put "value" in a tuple, because we want to pass it to functions + * that only accept PyTuples. Using "N" doesn't increment value's ref count */ + valtuple = Py_BuildValue("(N)", value); + + if (!valtuple) /* everything OK with our PyObject? */ + return EXPP_ReturnIntError(PyExc_MemoryError, + "MaterialSetAttr: couldn't create PyTuple"); + +/* Now we just compare "name" with all possible C_Material member variables */ + if (strcmp (name, "name") == 0) + error = Material_setName (self, valtuple); + else if (strcmp (name, "mode") == 0) + error = Material_setIntMode (self, valtuple); /* special case */ + else if (strcmp (name, "rgbCol") == 0) + error = Material_setRGBCol (self, valtuple); + else if (strcmp (name, "ambCol") == 0) + error = Material_setAmbCol (self, valtuple); + else if (strcmp (name, "specCol") == 0) + error = Material_setSpecCol (self, valtuple); + else if (strcmp (name, "mirCol") == 0) + error = Material_setMirCol (self, valtuple); + else if (strcmp (name, "R") == 0) + error = Material_setColorComponent (self, "R", valtuple); + else if (strcmp (name, "G") == 0) + error = Material_setColorComponent (self, "G", valtuple); + else if (strcmp (name, "B") == 0) + error = Material_setColorComponent (self, "B", valtuple); + else if (strcmp (name, "amb") == 0) + error = Material_setAmb (self, valtuple); + else if (strcmp (name, "ang") == 0) + error = Material_setAng (self, valtuple); + else if (strcmp (name, "emit") == 0) + error = Material_setEmit (self, valtuple); + else if (strcmp (name, "alpha") == 0) + error = Material_setAlpha (self, valtuple); + else if (strcmp (name, "ref") == 0) + error = Material_setRef (self, valtuple); + else if (strcmp (name, "spec") == 0) + error = Material_setSpec (self, valtuple); + else if (strcmp (name, "specTransp") == 0) + error = Material_setSpecTransp (self, valtuple); + else if (strcmp (name, "add") == 0) + error = Material_setAdd (self, valtuple); + else if (strcmp (name, "zOffset") == 0) + error = Material_setZOffset (self, valtuple); + else if (strcmp (name, "haloSize") == 0) + error = Material_setHaloSize (self, valtuple); + else if (strcmp (name, "flareSize") == 0) + error = Material_setFlareSize (self, valtuple); + else if (strcmp (name, "flareBoost") == 0) + error = Material_setFlareBoost (self, valtuple); + else if (strcmp (name, "subSize") == 0) + error = Material_setSubSize (self, valtuple); + else if (strcmp (name, "hard") == 0) + error = Material_setHardness (self, valtuple); + else if (strcmp (name, "nFlares") == 0) + error = Material_setNFlares (self, valtuple); + else if (strcmp (name, "nStars") == 0) + error = Material_setNStars (self, valtuple); + else if (strcmp (name, "nLines") == 0) + error = Material_setNLines (self, valtuple); + else if (strcmp (name, "nRings") == 0) + error = Material_setNRings (self, valtuple); + + else { /* Error */ + Py_DECREF(valtuple); + return (EXPP_ReturnIntError (PyExc_AttributeError, name)); + } + +/* valtuple won't be returned to the caller, so we need to DECREF it */ + Py_DECREF(valtuple); + + if (error != Py_None) return -1; + +/* Py_None was incref'ed by the called Material_set* function. We probably + * don't need to decref Py_None (!), but since Python/C API manual tells us + * to treat it like any other PyObject regarding ref counting ... */ + Py_DECREF(Py_None); + return 0; /* normal exit */ +} + +/*****************************************************************************/ +/* Function: MaterialPrint */ +/* Description: This is a callback function for the C_Material type. It */ +/* builds a meaninful string to 'print' material objects. */ +/*****************************************************************************/ +static int MaterialPrint(C_Material *self, FILE *fp, int flags) +{ + fprintf(fp, "[Material \"%s\"]", self->material->id.name+2); + return 0; +} + +/*****************************************************************************/ +/* Function: MaterialRepr */ +/* Description: This is a callback function for the C_Material type. It */ +/* builds a meaninful string to represent material objects. */ +/*****************************************************************************/ +static PyObject *MaterialRepr (C_Material *self) +{ + char buf[40]; + + PyOS_snprintf(buf, sizeof(buf), "[Material \"%s\"]", + self->material->id.name+2); + + return PyString_FromString(buf); +} diff --git a/source/blender/python/api2_2x/Material.h b/source/blender/python/api2_2x/Material.h new file mode 100644 index 00000000000..f3e0f706dce --- /dev/null +++ b/source/blender/python/api2_2x/Material.h @@ -0,0 +1,360 @@ +/* + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * This is a new part of Blender. + * + * Contributor(s): Willian P. Germano + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** +*/ + +#ifndef EXPP_MATERIAL_H +#define EXPP_MATERIAL_H + +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "constant.h" +#include "rgbTuple.h" +#include "gen_utils.h" +#include "modules.h" + +/*****************************************************************************/ +/* Python C_Material defaults: */ +/*****************************************************************************/ +#define EXPP_MAT_MODE_TRACEABLE MA_TRACEBLE +#define EXPP_MAT_MODE_SHADOW MA_SHADOW +#define EXPP_MAT_MODE_SHADELESS MA_SHLESS +#define EXPP_MAT_MODE_WIRE MA_WIRE +#define EXPP_MAT_MODE_VCOLLIGHT MA_VERTEXCOL +#define EXPP_MAT_MODE_HALO MA_HALO +#define EXPP_MAT_MODE_ZTRANSP MA_ZTRA +#define EXPP_MAT_MODE_VCOLPAINT MA_VERTEXCOLP +#define EXPP_MAT_MODE_ZINVERT MA_ZINV +#define EXPP_MAT_MODE_HALORINGS MA_HALO_RINGS +#define EXPP_MAT_MODE_ENV MA_ENV +#define EXPP_MAT_MODE_HALOLINES MA_HALO_LINES +#define EXPP_MAT_MODE_ONLYSHADOW MA_ONLYSHADOW +#define EXPP_MAT_MODE_XALPHA MA_HALO_XALPHA +#define EXPP_MAT_MODE_STAR MA_STAR +#define EXPP_MAT_MODE_FACETEX MA_FACETEXTURE +#define EXPP_MAT_MODE_HALOTEX MA_HALOTEX +#define EXPP_MAT_MODE_HALOPUNO MA_HALOPUNO +#define EXPP_MAT_MODE_NOMIST MA_NOMIST +#define EXPP_MAT_MODE_HALOSHADE MA_HALO_SHADE +#define EXPP_MAT_MODE_HALOFLARE MA_HALO_FLARE + +/* Material MIN, MAX values */ +#define EXPP_MAT_ADD_MIN 0.0 +#define EXPP_MAT_ADD_MAX 1.0 +#define EXPP_MAT_ALPHA_MIN 0.0 +#define EXPP_MAT_ALPHA_MAX 1.0 +#define EXPP_MAT_AMB_MIN 0.0 +#define EXPP_MAT_AMB_MAX 1.0 +#define EXPP_MAT_ANG_MIN 0.0 /* XXX Confirm these two */ +#define EXPP_MAT_ANG_MAX 1.0 +#define EXPP_MAT_COL_MIN 0.0 /* min/max for all ... */ +#define EXPP_MAT_COL_MAX 1.0 /* ... color triplets */ +#define EXPP_MAT_EMIT_MIN 0.0 +#define EXPP_MAT_EMIT_MAX 1.0 +#define EXPP_MAT_REF_MIN 0.0 +#define EXPP_MAT_REF_MAX 1.0 +#define EXPP_MAT_SPEC_MIN 0.0 +#define EXPP_MAT_SPEC_MAX 2.0 +#define EXPP_MAT_SPECTRA_MIN 0.0 +#define EXPP_MAT_SPECTRA_MAX 1.0 +#define EXPP_MAT_ZOFFS_MIN 0.0 +#define EXPP_MAT_ZOFFS_MAX 10.0 +#define EXPP_MAT_HALOSIZE_MIN 0.0 +#define EXPP_MAT_HALOSIZE_MAX 100.0 +#define EXPP_MAT_FLARESIZE_MIN 0.1 +#define EXPP_MAT_FLARESIZE_MAX 25.0 +#define EXPP_MAT_FLAREBOOST_MIN 0.1 +#define EXPP_MAT_FLAREBOOST_MAX 10.0 +#define EXPP_MAT_SUBSIZE_MIN 0.1 +#define EXPP_MAT_SUBSIZE_MAX 25.0 + +#define EXPP_MAT_HARD_MIN 1 +#define EXPP_MAT_HARD_MAX 255 /* 127 with MODE HALO ON */ +#define EXPP_MAT_NFLARES_MIN 1 +#define EXPP_MAT_NFLARES_MAX 32 +#define EXPP_MAT_NSTARS_MIN 3 +#define EXPP_MAT_NSTARS_MAX 50 +#define EXPP_MAT_NLINES_MIN 0 +#define EXPP_MAT_NLINES_MAX 250 +#define EXPP_MAT_NRINGS_MIN 0 +#define EXPP_MAT_NRINGS_MAX 24 + +/*****************************************************************************/ +/* Python API function prototypes for the Material module. */ +/*****************************************************************************/ +static PyObject *M_Material_New (PyObject *self, PyObject *args, + PyObject *keywords); +static PyObject *M_Material_Get (PyObject *self, PyObject *args); + +/*****************************************************************************/ +/* The following string definitions are used for documentation strings. */ +/* In Python these will be written to the console when doing a */ +/* Blender.Material.__doc__ */ +/*****************************************************************************/ +char M_Material_doc[] = +"The Blender Material module"; + +char M_Material_New_doc[] = +"(name) - return a new material called 'name'\n\ +() - return a new material called 'Mat'"; + +char M_Material_Get_doc[] = +"(name) - return the material called 'name', None if not found.\n\ +() - return a list of all materials in the current scene."; + +/*****************************************************************************/ +/* Python method structure definition for Blender.Material module: */ +/*****************************************************************************/ +struct PyMethodDef M_Material_methods[] = { + {"New",(PyCFunction)M_Material_New, METH_VARARGS|METH_KEYWORDS, + M_Material_New_doc}, + {"Get", M_Material_Get, METH_VARARGS, M_Material_Get_doc}, + {"get", M_Material_Get, METH_VARARGS, M_Material_Get_doc}, + {NULL, NULL, 0, NULL} +}; + +/*****************************************************************************/ +/* Python C_Material structure definition: */ +/*****************************************************************************/ +typedef struct { + PyObject_HEAD + Material *material; + C_rgbTuple *rgb, *amb, *spec, *mir; + +} C_Material; + +/*****************************************************************************/ +/* Python C_Material methods declarations: */ +/*****************************************************************************/ +static PyObject *Material_getName(C_Material *self); +static PyObject *Material_getMode(C_Material *self); +static PyObject *Material_getRGBCol(C_Material *self); +static PyObject *Material_getAmbCol(C_Material *self); +static PyObject *Material_getSpecCol(C_Material *self); +static PyObject *Material_getMirCol(C_Material *self); +static PyObject *Material_getAmb(C_Material *self); +static PyObject *Material_getAng(C_Material *self); +static PyObject *Material_getEmit(C_Material *self); +static PyObject *Material_getAlpha(C_Material *self); +static PyObject *Material_getRef(C_Material *self); +static PyObject *Material_getSpec(C_Material *self); +static PyObject *Material_getSpecTransp(C_Material *self); +static PyObject *Material_getAdd(C_Material *self); +static PyObject *Material_getZOffset(C_Material *self); +static PyObject *Material_getHaloSize(C_Material *self); +static PyObject *Material_getFlareSize(C_Material *self); +static PyObject *Material_getFlareBoost(C_Material *self); +static PyObject *Material_getSubSize(C_Material *self); +static PyObject *Material_getHardness(C_Material *self); +static PyObject *Material_getNFlares(C_Material *self); +static PyObject *Material_getNStars(C_Material *self); +static PyObject *Material_getNLines(C_Material *self); +static PyObject *Material_getNRings(C_Material *self); +static PyObject *Material_setName(C_Material *self, PyObject *args); +static PyObject *Material_setMode(C_Material *self, PyObject *args); +static PyObject *Material_setIntMode(C_Material *self, PyObject *args); +static PyObject *Material_setRGBCol(C_Material *self, PyObject *args); +static PyObject *Material_setAmbCol(C_Material *self, PyObject *args); +static PyObject *Material_setSpecCol(C_Material *self, PyObject *args); +static PyObject *Material_setMirCol(C_Material *self, PyObject *args); +static PyObject *Material_setAmb(C_Material *self, PyObject *args); +static PyObject *Material_setEmit(C_Material *self, PyObject *args); +static PyObject *Material_setAng(C_Material *self, PyObject *args); +static PyObject *Material_setAlpha(C_Material *self, PyObject *args); +static PyObject *Material_setRef(C_Material *self, PyObject *args); +static PyObject *Material_setSpec(C_Material *self, PyObject *args); +static PyObject *Material_setSpecTransp(C_Material *self, PyObject *args); +static PyObject *Material_setAdd(C_Material *self, PyObject *args); +static PyObject *Material_setZOffset(C_Material *self, PyObject *args); +static PyObject *Material_setHaloSize(C_Material *self, PyObject *args); +static PyObject *Material_setFlareSize(C_Material *self, PyObject *args); +static PyObject *Material_setFlareBoost(C_Material *self, PyObject *args); +static PyObject *Material_setSubSize(C_Material *self, PyObject *args); +static PyObject *Material_setHardness(C_Material *self, PyObject *args); +static PyObject *Material_setNFlares(C_Material *self, PyObject *args); +static PyObject *Material_setNStars(C_Material *self, PyObject *args); +static PyObject *Material_setNLines(C_Material *self, PyObject *args); +static PyObject *Material_setNRings(C_Material *self, PyObject *args); + +static PyObject *Material_setColorComponent(C_Material *self, char *key, + PyObject *args); + +/*****************************************************************************/ +/* Python C_Material methods table: */ +/*****************************************************************************/ +static PyMethodDef C_Material_methods[] = { + /* name, method, flags, doc */ + {"getName", (PyCFunction)Material_getName, METH_NOARGS, + "() - Return Material Data name"}, + {"getMode", (PyCFunction)Material_getMode, METH_NOARGS, + "() - Return Material mode flags"}, + {"getRGBCol", (PyCFunction)Material_getRGBCol, METH_NOARGS, + "() - Return Material's rgb color triplet"}, + {"getAmbCol", (PyCFunction)Material_getAmbCol, METH_NOARGS, + "() - Return Material's ambient color"}, + {"getSpecCol", (PyCFunction)Material_getSpecCol, METH_NOARGS, + "() - Return Material's specular color"}, + {"getMirCol", (PyCFunction)Material_getMirCol, METH_NOARGS, + "() - Return Material's mirror color"}, + {"getAmb", (PyCFunction)Material_getAmb, METH_NOARGS, + "() - Return Material's ambient color blend factor"}, + {"getAng", (PyCFunction)Material_getAng, METH_NOARGS, + "() - Return Material's ????"}, + {"getEmit", (PyCFunction)Material_getEmit, METH_NOARGS, + "() - Return Material's emitting light intensity"}, + {"getAlpha", (PyCFunction)Material_getAlpha, METH_NOARGS, + "() - Return Material's alpha (transparency) value"}, + {"getRef", (PyCFunction)Material_getRef, METH_NOARGS, + "() - Return Material's reflectivity"}, + {"getSpec", (PyCFunction)Material_getSpec, METH_NOARGS, + "() - Return Material's specularity"}, + {"getSpecTransp", (PyCFunction)Material_getSpecTransp, METH_NOARGS, + "() - Return Material's specular transparency"}, + {"getAdd", (PyCFunction)Material_getAdd, METH_NOARGS, + "() - Return Material's glow factor"}, + {"getZOffset", (PyCFunction)Material_getZOffset, METH_NOARGS, + "() - Return Material's artificial offset "}, + {"getHaloSize", (PyCFunction)Material_getHaloSize, METH_NOARGS, + "() - Return Material's halo size"}, + {"getFlareSize", (PyCFunction)Material_getFlareSize, METH_NOARGS, + "() - Return Material's (flare size)/(halo size) factor"}, + {"getFlareBoost", (PyCFunction)Material_getFlareBoost, METH_NOARGS, + "() - Return Material's flare boost"}, + {"getSubSize", (PyCFunction)Material_getSubSize, METH_NOARGS, + "() - Return Material's dimension of subflare, dots and circles"}, + {"getHardness", (PyCFunction)Material_getHardness, METH_NOARGS, + "() - Return Material's hardness"}, + {"getNFlares", (PyCFunction)Material_getNFlares, METH_NOARGS, + "() - Return Material's number of flares in halo"}, + {"getNStars", (PyCFunction)Material_getNStars, METH_NOARGS, + "() - Return Material's number of stars in halo"}, + {"getNLines", (PyCFunction)Material_getNLines, METH_NOARGS, + "() - Return Material's number of lines in halo"}, + {"getNRings", (PyCFunction)Material_getNRings, METH_NOARGS, + "() - Return Material's number of rings in halo"}, + {"setName", (PyCFunction)Material_setName, METH_VARARGS, + "(s) - Change Material Data name"}, + {"setMode", (PyCFunction)Material_setMode, METH_VARARGS, + "([s[,s]]) - Set Material mode flag(s)"}, + {"setRGBCol", (PyCFunction)Material_setMode, METH_VARARGS, + "([s[,s]]) - Set Material's rgb color triplet"}, + {"setAmbCol", (PyCFunction)Material_setMode, METH_VARARGS, + "([s[,s]]) - Set Material's ambient color"}, + {"setSpecCol", (PyCFunction)Material_setMode, METH_VARARGS, + "([s[,s]]) - Set Material's specular color"}, + {"setMirCol", (PyCFunction)Material_setMode, METH_VARARGS, + "([s[,s]]) - Set Material's mirror color"}, + {"setAmb", (PyCFunction)Material_setAmb, METH_VARARGS, + "(f) - Set how much the Material's color is affected" + " by \nthe global ambient colors - [0.0, 1.0]"}, + {"setAng", (PyCFunction)Material_setAng, METH_VARARGS, + "(f) - Set Material's ?????"}, + {"setEmit", (PyCFunction)Material_setEmit, METH_VARARGS, + "(f) - Set Material's emitting light intensity - [0.0, 1.0]"}, + {"setAlpha", (PyCFunction)Material_setAlpha, METH_VARARGS, + "(f) - Set Material's alpha (transparency) - [0.0, 1.0]"}, + {"setRef", (PyCFunction)Material_setRef, METH_VARARGS, + "(f) - Set Material's reflectivity - [0.0, 1.0]"}, + {"setSpec", (PyCFunction)Material_setSpec, METH_VARARGS, + "(f) - Set Material's specularity - [0.0, 2.0]"}, + {"setSpecTransp", (PyCFunction)Material_setSpecTransp, METH_VARARGS, + "(f) - Set Material's specular transparency - [0.0, 1.0]"}, + {"setAdd", (PyCFunction)Material_setAdd, METH_VARARGS, + "(f) - Set Material's glow factor - [0.0, 1.0]"}, + {"setZOffset", (PyCFunction)Material_setZOffset, METH_VARARGS, + "(f) - Set Material's artificial offset - [0.0, 10.0]"}, + {"setHaloSize", (PyCFunction)Material_setHaloSize, METH_VARARGS, + "(f) - Set Material's halo size - [0.0, 100.0]"}, + {"setFlareSize", (PyCFunction)Material_setFlareSize, METH_VARARGS, + "(f) - Set Material's factor: (flare size)/(halo size) - [0.1, 25.0]"}, + {"setFlareBoost", (PyCFunction)Material_setFlareBoost, METH_VARARGS, + "(f) - Set Material's flare boost - [0.1, 10.0]"}, + {"setSubSize", (PyCFunction)Material_setSubSize, METH_VARARGS, + "(f) - Set Material's dimension of subflare," + " dots and circles - [0.1, 25.0]"}, + {"setHardness", (PyCFunction)Material_setFlareBoost, METH_VARARGS, + "(f) - Set Material's hardness - [1, 255 (127 if halo mode is ON)]"}, + {"setNFlares", (PyCFunction)Material_setFlareBoost, METH_VARARGS, + "(f) - Set Material's number of flares in halo - [1, 32]"}, + {"setNStars", (PyCFunction)Material_setFlareBoost, METH_VARARGS, + "(f) - Set Material's number of stars in halo - [3, 50]"}, + {"setNLines", (PyCFunction)Material_setFlareBoost, METH_VARARGS, + "(f) - Set Material's number of lines in halo - [0, 250]"}, + {"setNRings", (PyCFunction)Material_setNRings, METH_VARARGS, + "(f) - Set Material's number of rings in halo - [0, 24]"}, + {0} +}; + +/*****************************************************************************/ +/* Python Material_Type callback function prototypes: */ +/*****************************************************************************/ +static void MaterialDeAlloc (C_Material *self); +static int MaterialPrint (C_Material *self, FILE *fp, int flags); +static int MaterialSetAttr (C_Material *self, char *name, PyObject *v); +static PyObject *MaterialGetAttr (C_Material *self, char *name); +static PyObject *MaterialRepr (C_Material *self); +static PyObject *Material_createPyObject (Material *mat); + +/*****************************************************************************/ +/* Python Material_Type structure definition: */ +/*****************************************************************************/ +PyTypeObject Material_Type = +{ + PyObject_HEAD_INIT(&PyType_Type) + 0, /* ob_size */ + "Material", /* tp_name */ + sizeof (C_Material), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)MaterialDeAlloc, /* tp_dealloc */ + (printfunc)MaterialPrint, /* tp_print */ + (getattrfunc)MaterialGetAttr, /* tp_getattr */ + (setattrfunc)MaterialSetAttr, /* tp_setattr */ + 0, /* tp_compare */ + (reprfunc)MaterialRepr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_as_hash */ + 0,0,0,0,0,0, + 0, /* tp_doc */ + 0,0,0,0,0,0, + C_Material_methods, /* tp_methods */ + 0, /* tp_members */ +}; + +#endif /* EXPP_MATERIAL_H */ diff --git a/source/blender/python/api2_2x/Object.c b/source/blender/python/api2_2x/Object.c index 3118069706c..71d8823faea 100644 --- a/source/blender/python/api2_2x/Object.c +++ b/source/blender/python/api2_2x/Object.c @@ -170,7 +170,7 @@ PyObject *M_Object_New(PyObject *self, PyObject *args) G.totobj++; /* Create a Python object from it. */ - blen_object = (C_Object*)PyObject_NEW (C_Object, &object_type); + blen_object = (C_Object*)PyObject_NEW (C_Object, &Object_Type); blen_object->object = object; blen_object->data = NULL; blen_object->parent = NULL; @@ -203,7 +203,7 @@ PyObject *M_Object_Get(PyObject *self, PyObject *args) return (PythonReturnErrorObject (PyExc_AttributeError, "Unknown object specified.")); } - blen_object = (C_Object*)PyObject_NEW (C_Object, &object_type); + blen_object = (C_Object*)PyObject_NEW (C_Object, &Object_Type); blen_object->object = object; blen_object->data = NULL; @@ -262,7 +262,7 @@ PyObject *M_Object_GetSelected (PyObject *self, PyObject *args) (G.scene->basact->lay & G.vd->lay))) { /* Active object is first in the list. */ - blen_object = (C_Object*)PyObject_NEW (C_Object, &object_type); + blen_object = (C_Object*)PyObject_NEW (C_Object, &Object_Type); if (blen_object == NULL) { Py_DECREF (list); @@ -281,7 +281,7 @@ PyObject *M_Object_GetSelected (PyObject *self, PyObject *args) (base_iter->lay & G.vd->lay)) && (base_iter != G.scene->basact)) { - blen_object = (C_Object*)PyObject_NEW (C_Object, &object_type); + blen_object = (C_Object*)PyObject_NEW (C_Object, &Object_Type); if (blen_object == NULL) { Py_DECREF (list); @@ -777,7 +777,7 @@ PyObject* M_ObjectCreatePyObject (struct Object *obj) printf ("In M_ObjectCreatePyObject\n"); - blen_object = (C_Object*)PyObject_NEW (C_Object, &object_type); + blen_object = (C_Object*)PyObject_NEW (C_Object, &Object_Type); if (blen_object == NULL) { @@ -794,7 +794,7 @@ PyObject* M_ObjectCreatePyObject (struct Object *obj) /*****************************************************************************/ int M_ObjectCheckPyObject (PyObject *py_obj) { - return (py_obj->ob_type == &object_type); + return (py_obj->ob_type == &Object_Type); } /*****************************************************************************/ diff --git a/source/blender/python/api2_2x/Object.h b/source/blender/python/api2_2x/Object.h index 365d63953d4..08316739b10 100644 --- a/source/blender/python/api2_2x/Object.h +++ b/source/blender/python/api2_2x/Object.h @@ -216,7 +216,7 @@ static PyObject* ObjectRepr (C_Object *obj); /*****************************************************************************/ /* Python TypeObject structure definition. */ /*****************************************************************************/ -static PyTypeObject object_type = +PyTypeObject Object_Type = { PyObject_HEAD_INIT(&PyType_Type) 0, /* ob_size */ diff --git a/source/blender/python/api2_2x/Text.h b/source/blender/python/api2_2x/Text.h index 723d77a7cb7..efac169cfcf 100644 --- a/source/blender/python/api2_2x/Text.h +++ b/source/blender/python/api2_2x/Text.h @@ -152,7 +152,7 @@ static PyObject *TextRepr (C_Text *self); /*****************************************************************************/ /* Python Text_Type structure definition: */ /*****************************************************************************/ -static PyTypeObject Text_Type = +PyTypeObject Text_Type = { PyObject_HEAD_INIT(&PyType_Type) 0, /* ob_size */ diff --git a/source/blender/python/api2_2x/Types.c b/source/blender/python/api2_2x/Types.c new file mode 100644 index 00000000000..7aa5c64ed14 --- /dev/null +++ b/source/blender/python/api2_2x/Types.c @@ -0,0 +1,74 @@ +/* + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * This is a new part of Blender. + * + * Contributor(s): Willian P. Germano + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** +*/ + +#include "Types.h" + +struct PyMethodDef Null_methods[] = {{NULL, NULL}}; + +/*****************************************************************************/ +/* Function: M_Types_Init */ +/*****************************************************************************/ +PyObject *M_Types_Init (void) +{ + PyObject *submodule, *dict; + + submodule = Py_InitModule3("Blender.Types", Null_methods, M_Types_doc); + + dict = PyModule_GetDict(submodule); + + /* The Blender Object Type */ + + PyDict_SetItemString(dict, "ObjectType", (PyObject *)&Object_Type); + + /* Blender Object Data Types */ + + PyDict_SetItemString(dict, "NMeshType", (PyObject *)&NMesh_Type); + PyDict_SetItemString(dict, "NMFaceType", (PyObject *)&NMFace_Type); + PyDict_SetItemString(dict, "NMVertType", (PyObject *)&NMVert_Type); + PyDict_SetItemString(dict, "NMColType", (PyObject *)&NMCol_Type); + + PyDict_SetItemString(dict, "CameraType", (PyObject *)&Camera_Type); + PyDict_SetItemString(dict, "ImageType", (PyObject *)&Image_Type); + PyDict_SetItemString(dict, "LampType", (PyObject *)&Lamp_Type); + PyDict_SetItemString(dict, "TextType", (PyObject *)&Text_Type); + + PyDict_SetItemString(dict, "ButtonType", (PyObject *)&Button_Type); + PyDict_SetItemString(dict, "MaterialType",(PyObject *)&Material_Type); + + /* External helper Types available to the main ones above */ + + PyDict_SetItemString(dict, "vectorType", (PyObject *)&vector_Type); + PyDict_SetItemString(dict, "bufferType", (PyObject *)&buffer_Type); + PyDict_SetItemString(dict, "constantType", (PyObject *)&constant_Type); + PyDict_SetItemString(dict, "rgbTupleType", (PyObject *)&rgbTuple_Type); + + return (submodule); +} diff --git a/source/blender/python/api2_2x/Types.h b/source/blender/python/api2_2x/Types.h new file mode 100644 index 00000000000..fe8d256008f --- /dev/null +++ b/source/blender/python/api2_2x/Types.h @@ -0,0 +1,50 @@ +/* + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * This is a new part of Blender. + * + * Contributor(s): Willian P. Germano + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** +*/ + +#ifndef EXPP_TYPES_H +#define EXPP_TYPES_H + +#include "Python.h" + +extern PyTypeObject Button_Type, Material_Type; + +extern PyTypeObject Object_Type; +extern PyTypeObject NMesh_Type, NMFace_Type, NMVert_Type, NMCol_Type; +extern PyTypeObject Camera_Type, Lamp_Type, Image_Type, Text_Type; + +extern PyTypeObject vector_Type, buffer_Type, rgbTuple_Type, + constant_Type; + +static char M_Types_doc[] = +"The Blender Types module\n\n\ +This module is a dictionary of all Blender Python types"; + +#endif /* EXPP_TYPES_H */ diff --git a/source/blender/python/api2_2x/constant.c b/source/blender/python/api2_2x/constant.c index 7640940903d..d116589b93b 100644 --- a/source/blender/python/api2_2x/constant.c +++ b/source/blender/python/api2_2x/constant.c @@ -115,10 +115,9 @@ static PyObject *new_const(void) /*****************************************************************************/ /* Python C_constant methods: */ /*****************************************************************************/ -void constant_insert(C_constant *self, char *key, PyObject *value) +int constant_insert (C_constant *self, char *name, PyObject *value) { - if (self->dict) - PyDict_SetItemString(self->dict, key, value); + return PyDict_SetItemString (self->dict, name, value); } /*****************************************************************************/ diff --git a/source/blender/python/api2_2x/constant.h b/source/blender/python/api2_2x/constant.h index ead902d9255..8d70c5051a0 100644 --- a/source/blender/python/api2_2x/constant.h +++ b/source/blender/python/api2_2x/constant.h @@ -51,11 +51,12 @@ PyObject *M_constant_New (void); typedef struct { PyObject_HEAD PyObject *dict; + } C_constant; /*****************************************************************************/ /* Python C_constant methods declarations: */ /*****************************************************************************/ -void constant_insert(C_constant *self, char *name, PyObject *args); +int constant_insert(C_constant *self, char *name, PyObject *value); #endif /* EXPP_constant_H */ diff --git a/source/blender/python/api2_2x/gen_utils.h b/source/blender/python/api2_2x/gen_utils.h index 6484f61e562..1fdd07d0d10 100644 --- a/source/blender/python/api2_2x/gen_utils.h +++ b/source/blender/python/api2_2x/gen_utils.h @@ -47,17 +47,17 @@ int StringEqual (char * string1, char * string2); char * GetIdName (ID *id); ID *GetIdFromList(ListBase *list, char *name); -PyObject * PythonReturnErrorObject (PyObject * type, char * error_msg); -PyObject * PythonIncRef (PyObject *object); -PyObject * EXPP_incr_ret (PyObject *object); +PyObject *PythonReturnErrorObject (PyObject * type, char * error_msg); +PyObject *PythonIncRef (PyObject *object); char * event_to_name (short event); float EXPP_ClampFloat (float value, float min, float max); int EXPP_ClampInt (int value, int min, int max); -int EXPP_ReturnIntError (PyObject *type, char *error_msg); +PyObject *EXPP_incr_ret (PyObject *object); PyObject *EXPP_ReturnPyObjError (PyObject * type, char * error_msg); +int EXPP_ReturnIntError (PyObject *type, char *error_msg); int EXPP_check_sequence_consistency (PyObject *seq, PyTypeObject *against); diff --git a/source/blender/python/api2_2x/modules.h b/source/blender/python/api2_2x/modules.h index b0c676da410..71375aaddc8 100644 --- a/source/blender/python/api2_2x/modules.h +++ b/source/blender/python/api2_2x/modules.h @@ -58,9 +58,15 @@ PyObject * M_ObjectCreatePyObject (struct Object *obj); int M_ObjectCheckPyObject (PyObject *py_obj); struct Object * M_ObjectFromPyObject (PyObject *py_obj); +/* Types */ +PyObject * M_Types_Init (void); + /* NMesh Data */ PyObject * M_NMesh_Init (void); +/* Material */ +PyObject * M_Material_Init (void); + /* Camera Data */ PyObject * M_Camera_Init (void); PyObject * Camera_createPyObject (struct Camera *cam); diff --git a/source/blender/python/api2_2x/rgbTuple.c b/source/blender/python/api2_2x/rgbTuple.c index 14a8476a8fe..8ee0665f440 100644 --- a/source/blender/python/api2_2x/rgbTuple.c +++ b/source/blender/python/api2_2x/rgbTuple.c @@ -110,7 +110,7 @@ PyTypeObject rgbTuple_Type = /* Function: rgbTuple_New */ /*****************************************************************************/ PyObject *rgbTuple_New(float *rgb[3]) -{ /* this is the static one */ +{ C_rgbTuple *rgbTuple; printf ("In rgbTuple_New()\n"); diff --git a/source/blender/python/api2_2x/vector.c b/source/blender/python/api2_2x/vector.c index 1e893a33dcd..a29fdbc9d13 100644 --- a/source/blender/python/api2_2x/vector.c +++ b/source/blender/python/api2_2x/vector.c @@ -35,7 +35,7 @@ /*****************************/ /* Vector Python Object */ /*****************************/ -#define VectorObject_Check(v) ((v)->ob_type == &Vector_Type) +#define VectorObject_Check(v) ((v)->ob_type == &vector_Type) static void Vector_dealloc(VectorObject *self) { @@ -191,7 +191,7 @@ static PySequenceMethods Vector_SeqMethods = (intintobjargproc) Vector_ass_slice, /* sq_ass_slice */ }; -PyTypeObject Vector_Type = +PyTypeObject vector_Type = { PyObject_HEAD_INIT(&PyType_Type) 0, /*ob_size*/ @@ -213,7 +213,7 @@ PyObject *newVectorObject(float *vec, int size) { VectorObject *self; - self= PyObject_NEW(VectorObject, &Vector_Type); + self= PyObject_NEW(VectorObject, &vector_Type); self->vec= vec; self->size= size;