archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

* Improved error checking in BPY_interface.c:

Browse Source 
Applied a fix suggested by Guignot
* Added part of Module Blender.Scene.
* Added doxygen comments to Camera.c .
This commit is contained in:
Willian Padovani Germano
2003-06-07 03:49:45 +00:00
parent b499fac975
commit ad61dd37ef
7 changed files with 962 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
source/blender/python/BPY_interface.c
View File

@@ -175,7 +175,13 @@ void BPY_Err_Handle(Text *text)
PyErr_Restore(exception, err, tb); // takes away reference! PyErr_Restore(exception, err, tb); // takes away reference!
PyErr_Print(); PyErr_Print();
tb = PySys_GetObject("last_traceback"); tb = PySys_GetObject("last_traceback");
Py_XINCREF(tb);
if (!tb) {
printf("\nCan't get traceback\n");
return;
}
Py_INCREF(tb);
/* From old bpython BPY_main.c: /* From old bpython BPY_main.c:
* 'check traceback objects and look for last traceback in the * 'check traceback objects and look for last traceback in the
@@ -422,41 +428,6 @@ int BPY_call_importloader(char *name)
return (0); return (0);
} }
/* XXX THE 3 FUNCTIONS BELOW ARE IMPLEMENTED IN DRAW.C */
/*****************************************************************************/
/* Description: */
/* Notes: Not implemented yet */
/*****************************************************************************/
//int BPY_spacetext_is_pywin(struct SpaceText *st)
//{
// /* No printf is done here because it is called with every mouse move */
// return (0);
//}
/*****************************************************************************/
/* Description: */
/* Notes: Not implemented yet */
/*****************************************************************************/
//void BPY_spacetext_do_pywin_draw(struct SpaceText *st)
//{
// printf ("In BPY_spacetext_do_pywin_draw\n");
// return;
//}
/*****************************************************************************/
/* Description: */
/* Notes: Not implemented yet */
/*****************************************************************************/
//void BPY_spacetext_do_pywin_event(struct SpaceText *st,
// unsigned short event,
// short val)
//{
// printf ("In BPY_spacetext_do_pywin_event(st=?, event=%d, val=%d)\n",
// event, val);
// return;
//}
/*****************************************************************************/ /*****************************************************************************/
/* Private functions */ /* Private functions */
/*****************************************************************************/ /*****************************************************************************/
@@ -476,7 +447,37 @@ PyObject * RunPython(Text *text, PyObject *globaldict)
* to speed-up execution if the user executes the script multiple times */ * to speed-up execution if the user executes the script multiple times */
if (!text->compiled) { /* if it wasn't already compiled, do it now */ if (!text->compiled) { /* if it wasn't already compiled, do it now */
buf = txt_to_buf(text);
#ifdef BLENDER_SANDBOX_MODE
/* IGNORE THIS ALL FOR A WHILE, IT'S VERY INCOMPLETE AND WILL CHANGE
* CONSIDERABLY IN THE NEXT COMMIT. THE ifdef won't stay, either. */
/* The import statement is a security risk, so we don't allow it in
* SANDBOX MODE. Instead, we import all needed modules ourselves and
* substitute all 'import' and '__import__' statements in the code by
* '#mport' and '#_import__', resp., making their lines become comments
* in Python (to let scripts run without import errors). */
/* Disable importing only for the safest sandbox mode */
txt_move_bof(text, 0); /* move to the beginning of the script */
/* Search all occurrences of 'import' in the script */
/* XXX Also check for from ... import ... */
while (txt_find_string (text, "import")) {
char *line = text->sell->line;
if (text->curc > 1) /* is it '__import__' ? */
if (strncmp (&line[text->curc - 2],
"__import__", 10) == 0) text->curc -= 2;
line[text->curc] = '#'; /* change them to '#mport' or '#_import__' */
}
#endif
buf = txt_to_buf(text);
text->compiled = Py_CompileString(buf, GetName(text), Py_file_input); text->compiled = Py_CompileString(buf, GetName(text), Py_file_input);
@@ -488,6 +489,11 @@ PyObject * RunPython(Text *text, PyObject *globaldict)
} }
} }
#ifdef BLENDER_SANDBOX_MODE
//save the script as a dict entry and call the eval code for it
//then return
PyDict_SetItemString(globaldict, "_SB_code", text->compiled);
#endif
return PyEval_EvalCode(text->compiled, globaldict, globaldict); return PyEval_EvalCode(text->compiled, globaldict, globaldict);
} }

1
source/blender/python/api2_2x/Blender.c
View File

@@ -214,6 +214,7 @@ void M_Blender_Init (void)
dict = PyModule_GetDict (module); dict = PyModule_GetDict (module);
g_blenderdict = dict; g_blenderdict = dict;
PyDict_SetItemString (dict, "Scene", M_Scene_Init());
PyDict_SetItemString (dict, "Object", M_Object_Init()); PyDict_SetItemString (dict, "Object", M_Object_Init());
PyDict_SetItemString (dict, "Types", M_Types_Init()); PyDict_SetItemString (dict, "Types", M_Types_Init());
PyDict_SetItemString (dict, "NMesh", M_NMesh_Init()); PyDict_SetItemString (dict, "NMesh", M_NMesh_Init());

360
source/blender/python/api2_2x/Camera.c
View File

@@ -29,6 +29,18 @@
* ***** END GPL/BL DUAL LICENSE BLOCK ***** * ***** END GPL/BL DUAL LICENSE BLOCK *****
*/ */
/**
* \file Camera.c
* \ingroup scripts
* \brief Blender.Camera Module and Camera Data PyObject implementation.
*
* Note: Parameters between "<" and ">" are optional. But if one of them is
* given, all preceding ones must be given, too. Of course, this only relates
* to the Python functions and methods described here and only inside Python
* code. [ This will go to another file later, probably the main exppython
* doc file].
*/
#include <BKE_main.h> #include <BKE_main.h>
#include <BKE_global.h> #include <BKE_global.h>
#include <BKE_object.h> #include <BKE_object.h>
@@ -137,8 +149,8 @@ static PyMethodDef BPy_Camera_methods[] = {
{"getType", (PyCFunction)Camera_getType, METH_NOARGS, {"getType", (PyCFunction)Camera_getType, METH_NOARGS,
"() - Return Camera type - 'persp':0, 'ortho':1"}, "() - Return Camera type - 'persp':0, 'ortho':1"},
{"getMode", (PyCFunction)Camera_getMode, METH_NOARGS, {"getMode", (PyCFunction)Camera_getMode, METH_NOARGS,
"() - Return Camera mode flags (or'ed value) -\n\t\ "() - Return Camera mode flags (or'ed value) -\n\t"
'showLimits':1, 'showMist':2"}, "'showLimits':1, 'showMist':2"},
{"getLens", (PyCFunction)Camera_getLens, METH_NOARGS, {"getLens", (PyCFunction)Camera_getLens, METH_NOARGS,
"() - Return Camera lens value"}, "() - Return Camera lens value"},
{"getClipStart", (PyCFunction)Camera_getClipStart, METH_NOARGS, {"getClipStart", (PyCFunction)Camera_getClipStart, METH_NOARGS,
@@ -202,10 +214,24 @@ PyTypeObject Camera_Type =
0, /* tp_members */ 0, /* tp_members */
}; };
/*****************************************************************************/ /**
/* Function: M_Camera_New */ * \defgroup Camera_Module Blender.Camera module functions
/* Python equivalent: Blender.Camera.New */ *
/*****************************************************************************/ */
/*@{*/
/**
* \brief Python module function: Blender.Camera.New()
*
* This is the .New() function of the Blender.Camera submodule. It creates
* new Camera Data in Blender and returns its Python wrapper object. The
* parameters are optional and default to type = 'persp' and name = 'CamData'.
* \param <type> - string: The Camera type: 'persp' or 'ortho';
* \param <name> - string: The Camera Data name.
* \return A new Camera PyObject.
*/
static PyObject *M_Camera_New(PyObject *self, PyObject *args, PyObject *kwords) static PyObject *M_Camera_New(PyObject *self, PyObject *args, PyObject *kwords)
{ {
char *type_str = "persp"; /* "persp" is type 0, "ortho" is type 1 */ char *type_str = "persp"; /* "persp" is type 0, "ortho" is type 1 */
@@ -255,33 +281,38 @@ static PyObject *M_Camera_New(PyObject *self, PyObject *args, PyObject *kwords)
return (PyObject *)pycam; return (PyObject *)pycam;
} }
/*****************************************************************************/ /**
/* Function: M_Camera_Get */ * \brief Python module function: Blender.Camera.Get()
/* Python equivalent: Blender.Camera.Get */ *
/* Description: Receives a string and returns the camera data obj */ * This is the .Get() function of the Blender.Camera submodule. It searches
/* whose name matches the string. If no argument is */ * the list of current Camera Data objects and returns a Python wrapper for
/* passed in, a list of all camera data names in the */ * the one with the name provided by the user. If called with no arguments,
/* current scene is returned. */ * it returns a list of all current Camera Data object names in Blender.
/*****************************************************************************/ * \param <name> - string: The name of an existing Blender Camera Data object.
* \return () - A list with the names of all current Camera Data objects;\n
* \return (name) - A Python wrapper for the Camera Data called 'name'
* in Blender.
*/
static PyObject *M_Camera_Get(PyObject *self, PyObject *args) static PyObject *M_Camera_Get(PyObject *self, PyObject *args)
{ {
char *name = NULL; char *name = NULL;
Camera *cam_iter; Camera *cam_iter;
if (!PyArg_ParseTuple(args, "|s", &name)) if (!PyArg_ParseTuple(args, "|s", &name))
return (EXPP_ReturnPyObjError (PyExc_TypeError, return (EXPP_ReturnPyObjError (PyExc_TypeError,
"expected string argument (or nothing)")); "expected string argument (or nothing)"));
cam_iter = G.main->camera.first; cam_iter = G.main->camera.first;
if (name) { /* (name) - Search camera by name */ if (name) { /* (name) - Search camera by name */
BPy_Camera *wanted_cam = NULL; BPy_Camera *wanted_cam = NULL;
while ((cam_iter) && (wanted_cam == NULL)) { while ((cam_iter) && (wanted_cam == NULL)) {
if (strcmp (name, cam_iter->id.name+2) == 0) { if (strcmp (name, cam_iter->id.name+2) == 0) {
wanted_cam = (BPy_Camera *)PyObject_NEW(BPy_Camera, &Camera_Type); wanted_cam = (BPy_Camera *)PyObject_NEW(BPy_Camera, &Camera_Type);
if (wanted_cam) wanted_cam->camera = cam_iter; if (wanted_cam) wanted_cam->camera = cam_iter;
} }
cam_iter = cam_iter->id.next; cam_iter = cam_iter->id.next;
} }
@@ -294,9 +325,9 @@ static PyObject *M_Camera_Get(PyObject *self, PyObject *args)
} }
return (PyObject *)wanted_cam; return (PyObject *)wanted_cam;
} }
else { /* () - return a list of all cameras in the scene */ else { /* () - return a list of all cameras in the scene */
int index = 0; int index = 0;
PyObject *camlist, *pystr; PyObject *camlist, *pystr;
@@ -306,27 +337,32 @@ static PyObject *M_Camera_Get(PyObject *self, PyObject *args)
return (PythonReturnErrorObject (PyExc_MemoryError, return (PythonReturnErrorObject (PyExc_MemoryError,
"couldn't create PyList")); "couldn't create PyList"));
while (cam_iter) { while (cam_iter) {
pystr = PyString_FromString (cam_iter->id.name+2); pystr = PyString_FromString (cam_iter->id.name+2);
if (!pystr) if (!pystr)
return (PythonReturnErrorObject (PyExc_MemoryError, return (PythonReturnErrorObject (PyExc_MemoryError,
"couldn't create PyString")); "couldn't create PyString"));
PyList_SET_ITEM (camlist, index, pystr); PyList_SET_ITEM (camlist, index, pystr);
cam_iter = cam_iter->id.next; cam_iter = cam_iter->id.next;
index++; index++;
} }
return (camlist); return (camlist);
} }
} }
/*@}*/
/**
* \brief Initializes the Blender.Camera submodule
*
* This function is used by Blender_Init() in Blender.c to register the
* Blender.Camera submodule in the main Blender module.
* \return PyObject*: The initialized submodule.
*/
/*****************************************************************************/
/* Function: M_Camera_Init */
/*****************************************************************************/
/* Needed by the Blender module, to register the Blender.Camera submodule */
PyObject *M_Camera_Init (void) PyObject *M_Camera_Init (void)
{ {
PyObject *submodule; PyObject *submodule;
@@ -343,49 +379,77 @@ PyObject *M_Camera_Init (void)
/* Three Python Camera_Type helper functions needed by the Object module: */ /* Three Python Camera_Type helper functions needed by the Object module: */
/*****************************************************************************/ /**
/* Function: Camera_CreatePyObject */ * \brief Creates a new Python wrapper from an existing Blender Camera Data obj
/* Description: This function will create a new BPy_Camera from an existing */ *
/* Blender camera structure. */ * This is also used in Object.c when defining the object.data member variable
/*****************************************************************************/ * for an Object of type 'Camera'.
* \param cam - Camera*: A pointer to an existing Blender Camera Data object.
* \return PyObject*: The Camera Data wrapper created.
*/
PyObject *Camera_CreatePyObject (Camera *cam) PyObject *Camera_CreatePyObject (Camera *cam)
{ {
BPy_Camera *pycam; BPy_Camera *pycam;
pycam = (BPy_Camera *)PyObject_NEW (BPy_Camera, &Camera_Type); pycam = (BPy_Camera *)PyObject_NEW (BPy_Camera, &Camera_Type);
if (!pycam) if (!pycam)
return EXPP_ReturnPyObjError (PyExc_MemoryError, return EXPP_ReturnPyObjError (PyExc_MemoryError,
"couldn't create BPy_Camera object"); "couldn't create BPy_Camera object");
pycam->camera = cam; pycam->camera = cam;
return (PyObject *)pycam; return (PyObject *)pycam;
} }
/*****************************************************************************/ /**
/* Function: Camera_CheckPyObject */ * \brief Checks if the given object is of type BPy_Camera
/* Description: This function returns true when the given PyObject is of the */ *
/* type Camera. Otherwise it will return false. */ * This is also used in Object.c when handling the object.data member variable
/*****************************************************************************/ * for an object of type 'Camera'.
* \param pyobj - PyObject*: A pointer to a Camera PyObject.
* \return int: True or false.
*/
int Camera_CheckPyObject (PyObject *pyobj) int Camera_CheckPyObject (PyObject *pyobj)
{ {
return (pyobj->ob_type == &Camera_Type); return (pyobj->ob_type == &Camera_Type);
} }
/*****************************************************************************/ /**
/* Function: Camera_FromPyObject */ * \brief Returns the Blender Camera object from the given PyObject
/* Description: This function returns the Blender camera from the given */ *
/* PyObject. */ * This is also used in Object.c when handling the object.data member variable
/*****************************************************************************/ * for an object of type 'Camera'.
* \param pyobj - PyObject*: A pointer to a Camera PyObject.
* \return Camera*: A pointer to the wrapped Blender Camera Data object.
*/
Camera *Camera_FromPyObject (PyObject *pyobj) Camera *Camera_FromPyObject (PyObject *pyobj)
{ {
return ((BPy_Camera *)pyobj)->camera; return ((BPy_Camera *)pyobj)->camera;
} }
/*****************************************************************************/ /*****************************************************************************/
/* Python BPy_Camera methods: */ /* Python BPy_Camera methods: */
/*****************************************************************************/ /*****************************************************************************/
/**
* \defgroup Camera_Methods Camera Method Functions
*
* These are the Camera PyObject method functions. They are used to get and
* set values for the Camera Data member variables.
*/
/*@{*/
/**
* \brief Camera PyMethod getName
*
* \return string: The Camera Data name.
*/
static PyObject *Camera_getName(BPy_Camera *self) static PyObject *Camera_getName(BPy_Camera *self)
{ {
PyObject *attr = PyString_FromString(self->camera->id.name+2); PyObject *attr = PyString_FromString(self->camera->id.name+2);
@@ -396,6 +460,12 @@ static PyObject *Camera_getName(BPy_Camera *self)
"couldn't get Camera.name attribute")); "couldn't get Camera.name attribute"));
} }
/**
* \brief Camera PyMethod getType
*
* \return int: The Camera Data type.
*/
static PyObject *Camera_getType(BPy_Camera *self) static PyObject *Camera_getType(BPy_Camera *self)
{ {
PyObject *attr = PyInt_FromLong(self->camera->type); PyObject *attr = PyInt_FromLong(self->camera->type);
@@ -406,6 +476,12 @@ static PyObject *Camera_getType(BPy_Camera *self)
"couldn't get Camera.type attribute")); "couldn't get Camera.type attribute"));
} }
/**
* \brief Camera PyMethod getMode
*
* \return int: The Camera Data mode flags.
*/
static PyObject *Camera_getMode(BPy_Camera *self) static PyObject *Camera_getMode(BPy_Camera *self)
{ {
PyObject *attr = PyInt_FromLong(self->camera->flag); PyObject *attr = PyInt_FromLong(self->camera->flag);
@@ -416,6 +492,12 @@ static PyObject *Camera_getMode(BPy_Camera *self)
"couldn't get Camera.Mode attribute")); "couldn't get Camera.Mode attribute"));
} }
/**
* \brief Camera PyMethod getLens
*
* \return float: The Camera Data lens value
*/
static PyObject *Camera_getLens(BPy_Camera *self) static PyObject *Camera_getLens(BPy_Camera *self)
{ {
PyObject *attr = PyFloat_FromDouble(self->camera->lens); PyObject *attr = PyFloat_FromDouble(self->camera->lens);
@@ -426,6 +508,12 @@ static PyObject *Camera_getLens(BPy_Camera *self)
"couldn't get Camera.lens attribute")); "couldn't get Camera.lens attribute"));
} }
/**
* \brief Camera PyMethod getClipStart
*
* \return float: The Camera Data clip start value.
*/
static PyObject *Camera_getClipStart(BPy_Camera *self) static PyObject *Camera_getClipStart(BPy_Camera *self)
{ {
PyObject *attr = PyFloat_FromDouble(self->camera->clipsta); PyObject *attr = PyFloat_FromDouble(self->camera->clipsta);
@@ -436,6 +524,11 @@ static PyObject *Camera_getClipStart(BPy_Camera *self)
"couldn't get Camera.clipStart attribute")); "couldn't get Camera.clipStart attribute"));
} }
/**
* \brief Camera PyMethod getClipEnd
* \return float: The Camera Data clip end value.
*/
static PyObject *Camera_getClipEnd(BPy_Camera *self) static PyObject *Camera_getClipEnd(BPy_Camera *self)
{ {
PyObject *attr = PyFloat_FromDouble(self->camera->clipend); PyObject *attr = PyFloat_FromDouble(self->camera->clipend);
@@ -446,6 +539,11 @@ static PyObject *Camera_getClipEnd(BPy_Camera *self)
"couldn't get Camera.clipEnd attribute")); "couldn't get Camera.clipEnd attribute"));
} }
/**
* \brief Camera method getDrawSize
* \return float: The Camera Data draw size value.
*/
static PyObject *Camera_getDrawSize(BPy_Camera *self) static PyObject *Camera_getDrawSize(BPy_Camera *self)
{ {
PyObject *attr = PyFloat_FromDouble(self->camera->drawsize); PyObject *attr = PyFloat_FromDouble(self->camera->drawsize);
@@ -456,6 +554,11 @@ static PyObject *Camera_getDrawSize(BPy_Camera *self)
"couldn't get Camera.drawSize attribute")); "couldn't get Camera.drawSize attribute"));
} }
/**
* \brief Camera PyMethod setName
* \param name - string: The new Camera Data name.
*/
static PyObject *Camera_setName(BPy_Camera *self, PyObject *args) static PyObject *Camera_setName(BPy_Camera *self, PyObject *args)
{ {
char *name; char *name;
@@ -473,6 +576,11 @@ static PyObject *Camera_setName(BPy_Camera *self, PyObject *args)
return Py_None; return Py_None;
} }
/**
* \brief Camera PyMethod setType
* \param type - string: The new Camera Data type: 'persp' or 'ortho'.
*/
static PyObject *Camera_setType(BPy_Camera *self, PyObject *args) static PyObject *Camera_setType(BPy_Camera *self, PyObject *args)
{ {
char *type; char *type;
@@ -498,6 +606,14 @@ static PyObject *Camera_setType(BPy_Camera *self, PyObject *args)
* in the first case t should be an int and in the second a string. So while * in the first case t should be an int and in the second a string. So while
* the method setType expects a string ('persp' or 'ortho') or an empty * the method setType expects a string ('persp' or 'ortho') or an empty
* argument, this function should receive an int (0 or 1). */ * argument, this function should receive an int (0 or 1). */
/**
* \brief Internal helper function
*
* This one is not a PyMethod. It is just an internal helper function.
* \param type - int: The Camera Data type as an int.
*/
static PyObject *Camera_setIntType(BPy_Camera *self, PyObject *args) static PyObject *Camera_setIntType(BPy_Camera *self, PyObject *args)
{ {
short value; short value;
@@ -516,6 +632,17 @@ static PyObject *Camera_setIntType(BPy_Camera *self, PyObject *args)
return Py_None; return Py_None;
} }
/**
* \brief Camera PyMethod setMode
*
* There are two mode flags for Cameras: 'showLimits' and 'showMist'.
* Both can be set at the same time, by providing two arguments to this
* method. To clear a flag, call setMode without the respective flag string
* in the argument list. For example: .setMode() clears both flags.
* \param mode1 - <string>: The first mode flag to set;
* \param mode2 - <string>: The second mode flag to set.
*/
static PyObject *Camera_setMode(BPy_Camera *self, PyObject *args) static PyObject *Camera_setMode(BPy_Camera *self, PyObject *args)
{ {
char *mode_str1 = NULL, *mode_str2 = NULL; char *mode_str1 = NULL, *mode_str2 = NULL;
@@ -553,6 +680,14 @@ static PyObject *Camera_setMode(BPy_Camera *self, PyObject *args)
/* Another helper function, for the same reason. /* Another helper function, for the same reason.
* (See comment before Camera_setIntType above). */ * (See comment before Camera_setIntType above). */
/**
* \brief Internal helper function
*
* This one is not a PyMethod. It is just an internal helper function.
* \param mode - int: The Camera Data mode as an int.
*/
static PyObject *Camera_setIntMode(BPy_Camera *self, PyObject *args) static PyObject *Camera_setIntMode(BPy_Camera *self, PyObject *args)
{ {
short value; short value;
@@ -571,6 +706,11 @@ static PyObject *Camera_setIntMode(BPy_Camera *self, PyObject *args)
return Py_None; return Py_None;
} }
/**
* \brief Camera PyMethod setLens
* \param lens - float: The new Camera Data lens value.
*/
static PyObject *Camera_setLens(BPy_Camera *self, PyObject *args) static PyObject *Camera_setLens(BPy_Camera *self, PyObject *args)
{ {
float value; float value;
@@ -586,6 +726,11 @@ static PyObject *Camera_setLens(BPy_Camera *self, PyObject *args)
return Py_None; return Py_None;
} }
/**
* \brief Camera PyMethod setClipStart
* \param clipStart - float: The new Camera Data clip start value.
*/
static PyObject *Camera_setClipStart(BPy_Camera *self, PyObject *args) static PyObject *Camera_setClipStart(BPy_Camera *self, PyObject *args)
{ {
float value; float value;
@@ -601,6 +746,11 @@ static PyObject *Camera_setClipStart(BPy_Camera *self, PyObject *args)
return Py_None; return Py_None;
} }
/**
* \brief Camera PyMethod setClipEnd
* \param clipEnd - float: The new Camera Data clip end value.
*/
static PyObject *Camera_setClipEnd(BPy_Camera *self, PyObject *args) static PyObject *Camera_setClipEnd(BPy_Camera *self, PyObject *args)
{ {
float value; float value;
@@ -616,6 +766,11 @@ static PyObject *Camera_setClipEnd(BPy_Camera *self, PyObject *args)
return Py_None; return Py_None;
} }
/**
* \brief Camera PyMethod setDrawSize
* \param drawSize - float: The new Camera Data draw size value.
*/
static PyObject *Camera_setDrawSize(BPy_Camera *self, PyObject *args) static PyObject *Camera_setDrawSize(BPy_Camera *self, PyObject *args)
{ {
float value; float value;
@@ -631,22 +786,33 @@ static PyObject *Camera_setDrawSize(BPy_Camera *self, PyObject *args)
return Py_None; return Py_None;
} }
/*****************************************************************************/ /*@}*/
/* Function: Camera_DeAlloc */
/* Description: This is a callback function for the BPy_Camera type. It is */ /**
/* the destructor function. */ * \defgroup Camera_callbacks Callback functions for the Camera PyType
/*****************************************************************************/ *
* These callbacks are called by the Python interpreter when dealing with
* PyObjects of type Camera.
*/
/*@{*/
/**
* \brief The Camera PyType destructor
*/
static void Camera_DeAlloc (BPy_Camera *self) static void Camera_DeAlloc (BPy_Camera *self)
{ {
PyObject_DEL (self); PyObject_DEL (self);
} }
/*****************************************************************************/ /**
/* Function: Camera_GetAttr */ * \brief The Camera PyType attribute getter
/* Description: This is a callback function for the BPy_Camera type. It is */ *
/* the function that accesses BPy_Camera "member variables" and */ * This is the callback called when a user tries to retrieve the contents of
/* methods. */ * Camera PyObject data members. Ex. in Python: "print mycamera.lens".
/*****************************************************************************/ */
static PyObject *Camera_GetAttr (BPy_Camera *self, char *name) static PyObject *Camera_GetAttr (BPy_Camera *self, char *name)
{ {
PyObject *attr = Py_None; PyObject *attr = Py_None;
@@ -692,12 +858,13 @@ static PyObject *Camera_GetAttr (BPy_Camera *self, char *name)
return Py_FindMethod(BPy_Camera_methods, (PyObject *)self, name); return Py_FindMethod(BPy_Camera_methods, (PyObject *)self, name);
} }
/*****************************************************************************/ /**
/* Function: Camera_SetAttr */ * \brief The Camera PyType attribute setter
/* Description: This is a callback function for the BPy_Camera type. It is */ *
/* the function that sets Camera Data attributes (member */ * This is the callback called when the user tries to change the value of some
/* variables). */ * Camera data member. Ex. in Python: "mycamera.lens = 45.0".
/*****************************************************************************/ */
static int Camera_SetAttr (BPy_Camera *self, char *name, PyObject *value) static int Camera_SetAttr (BPy_Camera *self, char *name, PyObject *value)
{ {
PyObject *valtuple; PyObject *valtuple;
@@ -757,37 +924,46 @@ static int Camera_SetAttr (BPy_Camera *self, char *name, PyObject *value)
return 0; /* normal exit */ return 0; /* normal exit */
} }
/*****************************************************************************/ /**
/* Function: Camera_Compare */ * \brief The Camera PyType compare function
/* Description: This is a callback function for the BPy_Camera type. It */ *
/* compares two Camera_Type objects. Only the "==" and "!=" */ * This function compares two given Camera PyObjects, returning 0 for equality
/* comparisons are meaninful. Returns 0 for equality and -1 if */ * and -1 otherwise. In Python it becomes 1 if they are equal and 0 case not.
/* they don't point to the same Blender Camera struct. */ * The comparison is done with their pointers to Blender Camera Data objects,
/* In Python it becomes 1 if they are equal, 0 otherwise. */ * so any two wrappers pointing to the same Blender Camera Data will be
/*****************************************************************************/ * considered the same Camera PyObject. Currently, only the "==" and "!="
* comparisons are meaninful -- the "<", "<=", ">" or ">=" are not.
*/
static int Camera_Compare (BPy_Camera *a, BPy_Camera *b) static int Camera_Compare (BPy_Camera *a, BPy_Camera *b)
{ {
Camera *pa = a->camera, *pb = b->camera; Camera *pa = a->camera, *pb = b->camera;
return (pa == pb) ? 0:-1; return (pa == pb) ? 0:-1;
} }
/*****************************************************************************/ /**
/* Function: Camera_Print */ * \brief The Camera PyType print callback
/* Description: This is a callback function for the BPy_Camera type. It */ *
/* builds a meaninful string to 'print' camera objects. */ * This function is called when the user tries to print a PyObject of type
/*****************************************************************************/ * Camera. It builds a string with the name of the wrapped Blender Camera.
*/
static int Camera_Print(BPy_Camera *self, FILE *fp, int flags) static int Camera_Print(BPy_Camera *self, FILE *fp, int flags)
{ {
fprintf(fp, "[Camera \"%s\"]", self->camera->id.name+2); fprintf(fp, "[Camera \"%s\"]", self->camera->id.name+2);
return 0; return 0;
} }
/*****************************************************************************/ /**
/* Function: Camera_Repr */ * \brief The Camera PyType repr callback
/* Description: This is a callback function for the BPy_Camera type. It */ *
/* builds a meaninful string to represent camera objects. */ * This function is called when the statement "repr(mycamera)" is executed in
/*****************************************************************************/ * Python. Repr gives a string representation of a PyObject.
*/
static PyObject *Camera_Repr (BPy_Camera *self) static PyObject *Camera_Repr (BPy_Camera *self)
{ {
return PyString_FromString(self->camera->id.name+2); return PyString_FromString(self->camera->id.name+2);
} }
/*@}*/

11
source/blender/python/api2_2x/Camera.h
View File

@@ -39,6 +39,12 @@
#include "constant.h" #include "constant.h"
#include "gen_utils.h" #include "gen_utils.h"
/* The Camera PyType Object defined in Camera.c */
PyTypeObject Camera_Type;
#define BPy_Camera_Check(v) \
((v)->ob_type == &Camera_Type) /* for type checking */
/*****************************************************************************/ /*****************************************************************************/
/* Python BPy_Camera structure definition: */ /* Python BPy_Camera structure definition: */
/*****************************************************************************/ /*****************************************************************************/
@@ -47,11 +53,6 @@ typedef struct {
Camera *camera; Camera *camera;
} BPy_Camera; } BPy_Camera;
PyTypeObject Camera_Type; /* The Camera PyType Object */
#define BPy_Camera_Check(v) \
((v)->ob_type == &Camera_Type) /* for type checking */
/*****************************************************************************/ /*****************************************************************************/
/* Python Camera_Type helper functions needed by Blender (the Init function) */ /* Python Camera_Type helper functions needed by Blender (the Init function) */
/* and Object modules. */ /* and Object modules. */

571
source/blender/python/api2_2x/Scene.c Normal file
View File

@@ -0,0 +1,571 @@
/*
*
* ***** 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 *****
*/
/**
* \file Scene.c
* \ingroup scripts
* \brief Blender.Scene Module and Scene PyObject implementation.
*
* Note: Parameters between "<" and ">" are optional. But if one of them is
* given, all preceding ones must be given, too. Of course, this only relates
* to the Python functions and methods described here and only inside Python
* code. [ This will go to another file later, probably the main exppython
* doc file].
*/
#include <BKE_main.h>
#include <BKE_global.h>
#include <BKE_scene.h>
#include <BKE_library.h>
#include <BLI_blenlib.h>
#include "Scene.h"
/*****************************************************************************/
/* Python BPy_Scene defaults: */
/*****************************************************************************/
/*****************************************************************************/
/* Python API function prototypes for the Scene module. */
/*****************************************************************************/
static PyObject *M_Scene_New (PyObject *self, PyObject *args,
PyObject *keywords);
static PyObject *M_Scene_Get (PyObject *self, PyObject *args);
static PyObject *M_Scene_getCurrent (PyObject *self);
static PyObject *M_Scene_unlink (PyObject *self, PyObject *arg);
/*****************************************************************************/
/* The following string definitions are used for documentation strings. */
/* In Python these will be written to the console when doing a */
/* Blender.Scene.__doc__ */
/*****************************************************************************/
static char M_Scene_doc[] = "";
static char M_Scene_New_doc[] = "";
static char M_Scene_Get_doc[] = "";
static char M_Scene_getCurrent_doc[] = "";
static char M_Scene_unlink_doc[] = "";
/*****************************************************************************/
/* Python method structure definition for Blender.Scene module: */
/*****************************************************************************/
struct PyMethodDef M_Scene_methods[] = {
{"New",(PyCFunction)M_Scene_New, METH_VARARGS|METH_KEYWORDS,
M_Scene_New_doc},
{"Get", M_Scene_Get, METH_VARARGS, M_Scene_Get_doc},
{"get", M_Scene_Get, METH_VARARGS, M_Scene_Get_doc},
{"getCurrent",(PyCFunction)M_Scene_getCurrent,
METH_NOARGS, M_Scene_getCurrent_doc},
{"unlink", M_Scene_unlink, METH_VARARGS, M_Scene_unlink_doc},
{NULL, NULL, 0, NULL}
};
/*****************************************************************************/
/* Python BPy_Scene methods declarations: */
/*****************************************************************************/
static PyObject *Scene_getName(BPy_Scene *self);
static PyObject *Scene_setName(BPy_Scene *self, PyObject *args);
/*****************************************************************************/
/* Python BPy_Scene methods table: */
/*****************************************************************************/
static PyMethodDef BPy_Scene_methods[] = {
/* name, method, flags, doc */
{"getName", (PyCFunction)Scene_getName, METH_NOARGS,
"() - Return Scene name"},
{"setName", (PyCFunction)Scene_setName, METH_VARARGS,
"(str) - Change Scene name"},
{0}
};
/*****************************************************************************/
/* Python Scene_Type callback function prototypes: */
/*****************************************************************************/
static void Scene_DeAlloc (BPy_Scene *self);
static int Scene_Print (BPy_Scene *self, FILE *fp, int flags);
static int Scene_SetAttr (BPy_Scene *self, char *name, PyObject *v);
static int Scene_Compare (BPy_Scene *a, BPy_Scene *b);
static PyObject *Scene_GetAttr (BPy_Scene *self, char *name);
static PyObject *Scene_Repr (BPy_Scene *self);
/*****************************************************************************/
/* Python Scene_Type structure definition: */
/*****************************************************************************/
PyTypeObject Scene_Type =
{
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
"Scene", /* tp_name */
sizeof (BPy_Scene), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor)Scene_DeAlloc, /* tp_dealloc */
(printfunc)Scene_Print, /* tp_print */
(getattrfunc)Scene_GetAttr, /* tp_getattr */
(setattrfunc)Scene_SetAttr, /* tp_setattr */
(cmpfunc)Scene_Compare, /* tp_compare */
(reprfunc)Scene_Repr, /* 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,
BPy_Scene_methods, /* tp_methods */
0, /* tp_members */
};
/**
* \defgroup Scene_Module Blender.Scene module functions
*
*/
/*@{*/
/**
* \brief Python module function: Blender.Scene.New()
*
* This is the .New() function of the Blender.Scene submodule. It creates
* new Scene in Blender and returns its Python wrapper object. The
* parameter is optional and defaults to name = 'Scene'.
* \param <name> - string: The Scene name.
* \return A new Scene PyObject.
*/
static PyObject *M_Scene_New(PyObject *self, PyObject *args, PyObject *kword)
{
char *name = "Scene";
char *kw[] = {"name", NULL};
PyObject *pyscene; /* for the Scene object wrapper in Python */
Scene *blscene; /* for the actual Scene we create in Blender */
printf ("In Scene_New()\n");
if (!PyArg_ParseTupleAndKeywords(args, kword, "|s", kw, &name))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected a string or an empty argument list"));
blscene = add_scene(name); /* first create the Scene in Blender */
if (blscene) /* now create the wrapper obj in Python */
pyscene = Scene_CreatePyObject (blscene);
else
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
"couldn't create Scene obj in Blender"));
if (pyscene == NULL)
return (EXPP_ReturnPyObjError (PyExc_MemoryError,
"couldn't create Scene PyObject"));
return pyscene;
}
/**
* \brief Python module function: Blender.Scene.Get()
*
* This is the .Get() function of the Blender.Scene submodule. It searches
* the list of current Scene objects and returns a Python wrapper for
* the one with the name provided by the user. If called with no arguments,
* it returns a list of all current Scene object names in Blender.
* \param <name> - string: The name of an existing Blender Scene object.
* \return () - A list with the names of all current Scene objects;\n
* \return (name) - A Python wrapper for the Scene called 'name'
* in Blender.
*/
static PyObject *M_Scene_Get(PyObject *self, PyObject *args)
{
char *name = NULL;
Scene *scene_iter;
if (!PyArg_ParseTuple(args, "|s", &name))
return (EXPP_ReturnPyObjError (PyExc_TypeError,
"expected string argument (or nothing)"));
scene_iter = G.main->scene.first;
if (name) { /* (name) - Search scene by name */
PyObject *wanted_scene = NULL;
while ((scene_iter) && (wanted_scene == NULL)) {
if (strcmp (name, scene_iter->id.name+2) == 0)
wanted_scene = Scene_CreatePyObject (scene_iter);
scene_iter = scene_iter->id.next;
}
if (wanted_scene == NULL) { /* Requested scene doesn't exist */
char error_msg[64];
PyOS_snprintf(error_msg, sizeof(error_msg),
"Scene \"%s\" not found", name);
return (EXPP_ReturnPyObjError (PyExc_NameError, error_msg));
}
return wanted_scene;
}
else { /* () - return a list of all scenes in Blender */
int index = 0;
PyObject *scenelist, *pystr;
scenelist = PyList_New (BLI_countlist (&(G.main->scene)));
if (scenelist == NULL)
return (PythonReturnErrorObject (PyExc_MemoryError,
"couldn't create PyList"));
while (scene_iter) {
pystr = PyString_FromString (scene_iter->id.name+2);
if (!pystr)
return (PythonReturnErrorObject (PyExc_MemoryError,
"couldn't create PyString"));
PyList_SET_ITEM (scenelist, index, pystr);
scene_iter = scene_iter->id.next;
index++;
}
return scenelist;
}
}
/**
* \brief Python module function: Blender.Scene.getCurrent()
*
* \return A Python wrapper for the currently active scene.
*/
PyObject *M_Scene_getCurrent (PyObject *self)
{
return Scene_CreatePyObject ((Scene *)G.scene);
}
/**
* \brief Python module function: Blender.Scene.unlink()
*
* This function actually frees the Blender Scene object linked to this
* Python wrapper. It calls free_libblock(), which calls free_scene(),
* where all objects linked to this scene have their user counts decremented.
* But there's no garbage collecting of objects in Blender yet.
* NOTE: a SystemError is raised if the user tries to remove the currently
* active Scene. Letting it be done would crash Blender.
* \param pyobj BPy_Scene*: A Scene PyObject wrapper.
*/
PyObject *M_Scene_unlink (PyObject *self, PyObject *arg)
{
PyObject *pyobj;
Scene *scene;
if (!PyArg_ParseTuple (arg, "O!", &Scene_Type, &pyobj))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected Scene PyType object");
scene = ((BPy_Scene *)pyobj)->scene;
if (scene == G.scene)
return EXPP_ReturnPyObjError (PyExc_SystemError,
"current Scene cannot be removed!");
free_libblock(&G.main->scene, scene);
Py_INCREF(Py_None);
return Py_None;
}
/*@}*/
/**
* \brief Initializes the Blender.Scene submodule
*
* This function is used by Blender_Init() in Blender.c to register the
* Blender.Scene submodule in the main Blender module.
* \return PyObject*: The initialized submodule.
*/
PyObject *M_Scene_Init (void)
{
PyObject *submodule;
printf ("In M_Scene_Init()\n");
Scene_Type.ob_type = &PyType_Type;
submodule = Py_InitModule3("Blender.Scene",
M_Scene_methods, M_Scene_doc);
return submodule;
}
/**
* \brief Creates a new Python wrapper from an existing Blender Scene obj
*
* \param scene - Scene*: A pointer to an existing Blender Scene object.
* \return PyObject*: The Scene wrapper created.
*/
PyObject *Scene_CreatePyObject (Scene *scene)
{
BPy_Scene *pyscene;
pyscene = (BPy_Scene *)PyObject_NEW (BPy_Scene, &Scene_Type);
if (!pyscene)
return EXPP_ReturnPyObjError (PyExc_MemoryError,
"couldn't create BPy_Scene object");
pyscene->scene = scene;
return (PyObject *)pyscene;
}
/**
* \brief Checks if the given object is of type BPy_Scene
*
* \param pyobj - PyObject*: A pointer to a Scene PyObject.
* \return int: True or false.
*/
int Scene_CheckPyObject (PyObject *pyobj)
{
return (pyobj->ob_type == &Scene_Type);
}
/**
* \brief Returns the Blender Scene object from the given PyObject
*
* \param pyobj - PyObject*: A pointer to a Scene PyObject.
* \return Scene*: A pointer to the wrapped Blender Scene object.
*/
Scene *Scene_FromPyObject (PyObject *pyobj)
{
return ((BPy_Scene *)pyobj)->scene;
}
/*****************************************************************************/
/* Python BPy_Scene methods: */
/*****************************************************************************/
/**
* \defgroup Scene_Methods Scene Method Functions
*
* These are the Scene PyObject method functions. They are used to get and
* set values for the Scene member variables.
*/
/*@{*/
/**
* \brief Scene PyMethod getName
*
* \return string: The Scene name.
*/
static PyObject *Scene_getName(BPy_Scene *self)
{
PyObject *attr = PyString_FromString(self->scene->id.name+2);
if (attr) return attr;
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
"couldn't get Scene.name attribute"));
}
/**
* \brief Scene PyMethod setName
* \param name - string: The new Scene name.
*/
static PyObject *Scene_setName(BPy_Scene *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->scene->id, buf);
Py_INCREF(Py_None);
return Py_None;
}
/*@}*/
/**
* \defgroup Scene_callbacks Callback functions for the Scene PyType
*
* These callbacks are called by the Python interpreter when dealing with
* PyObjects of type Scene.
*/
/*@{*/
/**
* \brief The Scene PyType destructor
*/
static void Scene_DeAlloc (BPy_Scene *self)
{
PyObject_DEL (self);
}
/**
* \brief The Scene PyType attribute getter
*
* This is the callback called when a user tries to retrieve the contents of
* Scene PyObject data members. Ex. in Python: "print myscene.lens".
*/
static PyObject *Scene_GetAttr (BPy_Scene *self, char *name)
{
PyObject *attr = Py_None;
if (strcmp(name, "name") == 0)
attr = PyString_FromString(self->scene->id.name+2);
else if (strcmp(name, "__members__") == 0) {
attr = Py_BuildValue("[s,s,s,s,s,s,s,s,s]",
"name", "type", "mode", "lens", "clipStart",
"clipEnd", "drawSize", "Types", "Modes");
}
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(BPy_Scene_methods, (PyObject *)self, name);
}
/**
* \brief The Scene PyType attribute setter
*
* This is the callback called when the user tries to change the value of some
* Scene data member. Ex. in Python: "myscene.lens = 45.0".
*/
static int Scene_SetAttr (BPy_Scene *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
* Scene.member = val instead of Scene.setMember(val), we end up using the
* function anyway, since it already has error checking, clamps to the right
* interval and updates the Blender Scene 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,
"SceneSetAttr: couldn't create PyTuple");
/* Now we just compare "name" with all possible BPy_Scene member variables */
if (strcmp (name, "name") == 0)
error = Scene_setName (self, valtuple);
else { /* Error: no member with the given name was found */
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 Scene_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 */
}
/**
* \brief The Scene PyType compare function
*
* This function compares two given Scene PyObjects, returning 0 for equality
* and -1 otherwise. In Python it becomes 1 if they are equal and 0 case not.
* The comparison is done with their pointers to Blender Scene objects,
* so any two wrappers pointing to the same Blender Scene will be
* considered the same Scene PyObject. Currently, only the "==" and "!="
* comparisons are meaninful -- the "<", "<=", ">" or ">=" are not.
*/
static int Scene_Compare (BPy_Scene *a, BPy_Scene *b)
{
Scene *pa = a->scene, *pb = b->scene;
return (pa == pb) ? 0:-1;
}
/**
* \brief The Scene PyType print callback
*
* This function is called when the user tries to print a PyObject of type
* Scene. It builds a string with the name of the wrapped Blender Scene.
*/
static int Scene_Print(BPy_Scene *self, FILE *fp, int flags)
{
fprintf(fp, "[Scene \"%s\"]", self->scene->id.name+2);
return 0;
}
/**
* \brief The Scene PyType repr callback
*
* This function is called when the statement "repr(myscene)" is executed in
* Python. Repr gives a string representation of a PyObject.
*/
static PyObject *Scene_Repr (BPy_Scene *self)
{
return PyString_FromString(self->scene->id.name+2);
}
/*@}*/

66
source/blender/python/api2_2x/Scene.h Normal file
View File

@@ -0,0 +1,66 @@
/*
*
* ***** 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_SCENE_H
#define EXPP_SCENE_H
#include <Python.h>
#include <DNA_scene_types.h>
#include "constant.h"
#include "gen_utils.h"
/* The Scene PyType Object defined in Scene.c */
PyTypeObject Scene_Type;
#define BPy_Scene_Check(v) \
((v)->ob_type == &Scene_Type) /* for type checking */
/*****************************************************************************/
/* Python BPy_Scene structure definition: */
/*****************************************************************************/
typedef struct {
PyObject_HEAD
Scene *scene;
} BPy_Scene;
/*****************************************************************************/
/* Python Scene_Type helper functions needed by Blender (the Init function) */
/* and Object modules. */
/*****************************************************************************/
PyObject *M_Scene_Init (void);
PyObject *Scene_CreatePyObject (Scene *cam);
Scene *Scene_FromPyObject (PyObject *pyobj);
int Scene_CheckPyObject (PyObject *pyobj);
#endif /* EXPP_SCENE_H */

7
source/blender/python/api2_2x/modules.h
View File

@@ -34,6 +34,7 @@
#include <Python.h> #include <Python.h>
#include <DNA_scene_types.h>
#include <DNA_object_types.h> #include <DNA_object_types.h>
#include <DNA_camera_types.h> #include <DNA_camera_types.h>
#include <DNA_lamp_types.h> #include <DNA_lamp_types.h>
@@ -62,6 +63,12 @@ PyObject * M_ObjectCreatePyObject (struct Object *obj);
int M_ObjectCheckPyObject (PyObject *py_obj); int M_ObjectCheckPyObject (PyObject *py_obj);
struct Object * M_ObjectFromPyObject (PyObject *py_obj); struct Object * M_ObjectFromPyObject (PyObject *py_obj);
/* Scene */
PyObject * M_Scene_Init (void);
PyObject * Scene_CreatePyObject (struct Scene *sce);
Scene * Scene_FromPyObject (PyObject *pyobj);
int Scene_CheckPyObject (PyObject *pyobj);
/* Types */ /* Types */
PyObject * M_Types_Init (void); PyObject * M_Types_Init (void);