BPython:

- new submodule Scene.Radio, for radiosity: still incomplete, but in shape for demos, updated SConscript to include it;
- new functions in Window module;
- doc updates: adding a todo file and a new start page for our docs: API_intro.py + other updates;
- small fix in Ipo.c provided by Damien McGuinnes (thanks!): Nathan has a patch with IPO additions and fixes for this and more, but until it is committed, there's this fix for Ipo.getCurve('LocX'), LocY, Z and QuatW,X,Y,Z too, according to Damien.

Other files:
- radpreprocess.c: added check for "during_script()" so eventual msgs don't popup during scripts;
- drawmesh.c: made a pointer (display list) be checked before accessed, fixes crash in scripts that forget to update display lists for subsurf meshes when a 3d view is in textured view mode.

Script: updated bevel_center by Loic Berthe.

1 files changed, 638 insertions, 0 deletions

diff --git a/source/blender/python/api2_2x/sceneRadio.c b/source/blender/python/api2_2x/sceneRadio.c
new file mode 100644
index 00000000000..7b631bb1292
--- /dev/null
+++ b/source/blender/python/api2_2x/sceneRadio.c
@@ -0,0 +1,638 @@
+/* 
+ *
+ * ***** 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 "sceneRadio.h" /* includes Python.h */
+#include <radio.h>
+#include <BKE_object.h> /* disable_where_script() */
+
+#include "constant.h"
+#include "gen_utils.h"
+
+/* bitflags */
+#define EXPP_RADIO_flag_SHOWLIM 1
+#define EXPP_RADIO_flag_Z 2
+/* shorts */
+#define EXPP_RADIO_hemires_MIN 100
+#define EXPP_RADIO_hemires_MAX 1000
+#define EXPP_RADIO_maxiter_MIN 0
+#define EXPP_RADIO_maxiter_MAX 10000
+#define EXPP_RADIO_subshootp_MIN 0
+#define EXPP_RADIO_subshootp_MAX 10
+#define EXPP_RADIO_subshoote_MIN 0
+#define EXPP_RADIO_subshoote_MAX 10
+#define EXPP_RADIO_nodelim_MIN 0
+#define EXPP_RADIO_nodelim_MAX 50
+#define EXPP_RADIO_maxsublamp_MIN 1
+#define EXPP_RADIO_maxsublamp_MAX 250
+#define EXPP_RADIO_pama_MIN 10
+#define EXPP_RADIO_pama_MAX 1000
+#define EXPP_RADIO_pami_MIN 10
+#define EXPP_RADIO_pami_MAX 1000
+#define EXPP_RADIO_elma_MIN 1
+#define EXPP_RADIO_elma_MAX 500
+#define EXPP_RADIO_elmi_MIN 1
+#define EXPP_RADIO_elmi_MAX 500
+/* ints */
+#define EXPP_RADIO_maxnode_MIN 1
+#define EXPP_RADIO_maxnode_MAX 250000
+/* floats */
+#define EXPP_RADIO_convergence_MIN 0.0
+#define EXPP_RADIO_convergence_MAX 0.1
+#define EXPP_RADIO_radfac_MIN 0.001
+#define EXPP_RADIO_radfac_MAX 250.0
+#define EXPP_RADIO_gamma_MIN 0.2
+#define EXPP_RADIO_gamma_MAX 10.0
+/* drawtypes */
+#define EXPP_RADIO_drawtype_WIRE 0
+#define EXPP_RADIO_drawtype_SOLID 1
+#define EXPP_RADIO_drawtype_GOURAUD 2
+
+static int EXPP_check_scene(Scene *scene)
+{
+	if (scene != G.scene) {
+		PyErr_SetString(PyExc_EnvironmentError,
+		"\nradiosity only works on the current scene, check scene.makeCurrent().");
+		return 0;
+	}
+	else if (!scene->radio) {
+		PyErr_SetString(PyExc_EnvironmentError,
+			"\nradiosity data was deleted from scene!");
+		return 0;
+	}
+
+	return 1;
+}
+
+static PyObject *Radio_collectMeshes(BPy_Radio *self);
+static PyObject *Radio_go(BPy_Radio *self);
+static PyObject *Radio_freeData(BPy_Radio *self);
+
+static void Radio_dealloc (BPy_Radio *self);
+static PyObject *Radio_repr (BPy_Radio *self);
+
+static PyObject *EXPP_create_ret_PyInt(int value)
+{
+	PyObject *pyval = PyInt_FromLong(value);
+
+	if (!pyval)
+		PyErr_SetString(PyExc_MemoryError, "couldn't create py int!");
+
+	return pyval;
+}
+
+static PyObject *EXPP_create_ret_PyFloat(float value)
+{
+	PyObject *pyval = PyFloat_FromDouble((double)value);
+
+	if (!pyval)
+		PyErr_SetString(PyExc_MemoryError, "couldn't create py int!");
+
+	return pyval;
+}
+
+static PyObject *Radio_get_hemires(BPy_Radio *self)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_create_ret_PyInt((int)self->scene->radio->hemires);
+}
+
+static PyObject *Radio_get_maxiter(BPy_Radio *self)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_create_ret_PyInt((int)self->scene->radio->maxiter);
+}
+
+static PyObject *Radio_get_subshootp(BPy_Radio *self)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_create_ret_PyInt((int)self->scene->radio->subshootp);
+}
+
+static PyObject *Radio_get_subshoote(BPy_Radio *self)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_create_ret_PyInt((int)self->scene->radio->subshoote);
+}
+
+static PyObject *Radio_get_nodelim(BPy_Radio *self)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_create_ret_PyInt((int)self->scene->radio->nodelim);
+}
+
+static PyObject *Radio_get_maxsublamp(BPy_Radio *self)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_create_ret_PyInt((int)self->scene->radio->maxsublamp);
+}
+
+static PyObject *Radio_get_pama(BPy_Radio *self)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_create_ret_PyInt((int)self->scene->radio->pama);
+}
+
+static PyObject *Radio_get_pami(BPy_Radio *self)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_create_ret_PyInt((int)self->scene->radio->pami);
+}
+
+static PyObject *Radio_get_elma(BPy_Radio *self)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_create_ret_PyInt((int)self->scene->radio->elma);
+}
+
+static PyObject *Radio_get_elmi(BPy_Radio *self)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_create_ret_PyInt((int)self->scene->radio->elmi);
+}
+
+static PyObject *Radio_get_drawtype(BPy_Radio *self)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_create_ret_PyInt((int)self->scene->radio->drawtype);
+}
+
+static PyObject *Radio_get_flag(BPy_Radio *self)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_create_ret_PyInt((int)self->scene->radio->flag);
+}
+
+static PyObject *Radio_get_maxnode(BPy_Radio *self)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_create_ret_PyInt((int)self->scene->radio->maxnode);
+}
+
+static PyObject *Radio_get_convergence(BPy_Radio *self)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_create_ret_PyFloat(self->scene->radio->convergence);
+}
+
+static PyObject *Radio_get_radfac(BPy_Radio *self)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_create_ret_PyFloat(self->scene->radio->radfac);
+}
+
+static PyObject *Radio_get_gamma(BPy_Radio *self)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_create_ret_PyFloat(self->scene->radio->gamma);
+}
+
+static PyObject *EXPP_unpack_set_int(PyObject *args, int *ptr,
+	int min, int max)
+{
+	int value;
+
+	if (!PyArg_ParseTuple(args, "i", &value))
+		return EXPP_ReturnPyObjError (PyExc_TypeError,
+			"expected int argument");
+
+	*ptr = EXPP_ClampInt(value, min, max);
+
+	return EXPP_incr_ret (Py_None);
+}
+
+/* could merge with set_int, but is cleaner this way */
+static PyObject *EXPP_unpack_set_short(PyObject *args, short *ptr,
+	short min, short max)
+{
+	int value;
+
+	if (!PyArg_ParseTuple(args, "i", &value))
+		return EXPP_ReturnPyObjError (PyExc_TypeError,
+			"expected int argument");
+
+	*ptr = (short)EXPP_ClampInt(value, min, max);
+
+	return EXPP_incr_ret (Py_None);
+}
+
+static PyObject *EXPP_unpack_set_float(PyObject *args, float *ptr,
+	float min, float max)
+{
+	float value;
+
+	if (!PyArg_ParseTuple(args, "f", &value))
+		return EXPP_ReturnPyObjError (PyExc_TypeError,
+			"expected float argument");
+
+	*ptr = EXPP_ClampFloat(value, min, max);
+
+	return EXPP_incr_ret (Py_None);
+}
+
+static PyObject *Radio_set_hemires(BPy_Radio *self, PyObject *args)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_unpack_set_short(args, &self->scene->radio->hemires,
+		EXPP_RADIO_hemires_MIN, EXPP_RADIO_hemires_MAX);
+}
+
+static PyObject *Radio_set_maxiter(BPy_Radio *self, PyObject *args)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_unpack_set_short(args, &self->scene->radio->maxiter,
+		EXPP_RADIO_maxiter_MIN, EXPP_RADIO_maxiter_MAX);
+}
+
+static PyObject *Radio_set_subshootp(BPy_Radio *self, PyObject *args)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_unpack_set_short(args, &self->scene->radio->subshootp,
+		EXPP_RADIO_subshootp_MIN, EXPP_RADIO_subshootp_MAX);
+}
+
+static PyObject *Radio_set_subshoote(BPy_Radio *self, PyObject *args)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_unpack_set_short(args, &self->scene->radio->subshoote,
+		EXPP_RADIO_subshoote_MIN, EXPP_RADIO_subshoote_MAX);
+}
+
+static PyObject *Radio_set_nodelim(BPy_Radio *self, PyObject *args)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_unpack_set_short(args, &self->scene->radio->nodelim,
+		EXPP_RADIO_nodelim_MIN, EXPP_RADIO_nodelim_MAX);
+}
+
+static PyObject *Radio_set_maxsublamp(BPy_Radio *self, PyObject *args)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_unpack_set_short(args, &self->scene->radio->maxsublamp,
+		EXPP_RADIO_maxsublamp_MIN, EXPP_RADIO_maxsublamp_MAX);
+}
+
+static PyObject *Radio_set_pama(BPy_Radio *self, PyObject *args)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_unpack_set_short(args, &self->scene->radio->pama,
+		EXPP_RADIO_pama_MIN, EXPP_RADIO_pama_MAX);
+}
+
+static PyObject *Radio_set_pami(BPy_Radio *self, PyObject *args)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_unpack_set_short(args, &self->scene->radio->pami,
+		EXPP_RADIO_pami_MIN, EXPP_RADIO_pami_MAX);
+}
+
+static PyObject *Radio_set_elma(BPy_Radio *self, PyObject *args)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_unpack_set_short(args, &self->scene->radio->elma,
+		EXPP_RADIO_elma_MIN, EXPP_RADIO_elma_MAX);
+}
+
+static PyObject *Radio_set_elmi(BPy_Radio *self, PyObject *args)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_unpack_set_short(args, &self->scene->radio->elmi,
+		EXPP_RADIO_elmi_MIN, EXPP_RADIO_elmi_MAX);
+}
+
+static PyObject *Radio_set_drawtype(BPy_Radio *self, PyObject *args)
+{
+	PyObject *pyob = NULL;
+	char *str = NULL;
+	short dt = EXPP_RADIO_drawtype_WIRE;
+
+	if (!EXPP_check_scene(self->scene)) return NULL;
+
+	if (!PyArg_ParseTuple (args, "O", &pyob))
+		return EXPP_ReturnPyObjError(PyExc_TypeError,
+			"expected int or string as argument");
+
+	if (PyString_Check(pyob)) {
+		str = PyString_AsString(pyob);
+		if (!str)
+			return EXPP_ReturnPyObjError (PyExc_MemoryError,
+				"couldn't create py string!");
+		else if (!strcmp(str, "Wire")) dt = EXPP_RADIO_drawtype_WIRE;
+		else if (!strcmp(str, "Solid")) dt = EXPP_RADIO_drawtype_SOLID;
+		else if (!strcmp(str, "Gouraud")) dt = EXPP_RADIO_drawtype_GOURAUD;
+		else
+			return EXPP_ReturnPyObjError (PyExc_AttributeError,
+				"unknown drawtype string");
+	}
+	else if (PyInt_Check(pyob)) {
+		dt = (short)EXPP_ClampInt(PyInt_AsLong(pyob),
+			EXPP_RADIO_drawtype_WIRE, EXPP_RADIO_drawtype_GOURAUD);
+	}
+	else
+		return EXPP_ReturnPyObjError (PyExc_TypeError,
+			"expected int or string as argument");
+
+	self->scene->radio->drawtype = dt;
+
+	return EXPP_incr_ret (Py_None);
+}
+
+static PyObject *Radio_set_flag(BPy_Radio *self, PyObject *args)
+{
+	int i, imode = 0;
+	char *mode[2] = {NULL, NULL};
+
+	if (!EXPP_check_scene(self->scene)) return NULL;
+
+	if (!PyArg_ParseTuple(args, "|ss", &mode[0], &mode[1]))
+		return EXPP_ReturnPyObjError (PyExc_TypeError,
+			"expected string arguments (or nothing)");
+
+	for (i = 0; i < 2; i++) {
+		if (!mode[i]) break;
+		else if (!strcmp(mode[i], "ShowLimits")) imode |= EXPP_RADIO_flag_SHOWLIM;
+		else if (!strcmp(mode[i], "Z")) imode |= EXPP_RADIO_flag_Z;
+	}
+
+	self->scene->radio->flag = (short)EXPP_ClampInt(imode, 0, 3);
+
+	return EXPP_incr_ret(Py_None);
+}
+
+static PyObject *Radio_set_maxnode(BPy_Radio *self, PyObject *args)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_unpack_set_int(args, &self->scene->radio->maxnode,
+		EXPP_RADIO_maxnode_MIN, EXPP_RADIO_maxnode_MAX);
+}
+
+static PyObject *Radio_set_convergence(BPy_Radio *self, PyObject *args)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_unpack_set_float(args, &self->scene->radio->convergence,
+		EXPP_RADIO_convergence_MIN, EXPP_RADIO_convergence_MAX);
+}
+
+static PyObject *Radio_set_radfac(BPy_Radio *self, PyObject *args)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_unpack_set_float(args, &self->scene->radio->radfac,
+		EXPP_RADIO_radfac_MIN, EXPP_RADIO_radfac_MAX);
+}
+
+static PyObject *Radio_set_gamma(BPy_Radio *self, PyObject *args)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+	return EXPP_unpack_set_float(args, &self->scene->radio->gamma,
+		EXPP_RADIO_gamma_MIN, EXPP_RADIO_gamma_MAX);
+}
+
+static PyMethodDef BPy_Radio_methods[] = {
+	{"collectMeshes", (PyCFunction) Radio_collectMeshes, METH_NOARGS,
+		"() - Convert selected meshes to patches."},
+	{"go", (PyCFunction) Radio_go, METH_NOARGS,
+		"() - Start radiosity calculations."},
+	{"freeData", (PyCFunction) Radio_freeData, METH_NOARGS,
+		"() - Free all memory used by radiosity."},
+	{"getHemiRes", (PyCFunction) Radio_get_hemires, METH_NOARGS,
+		"() - Get hemicube size."},
+	{"setHemiRes", (PyCFunction) Radio_set_hemires, METH_VARARGS,
+		"(int) - Set hemicube size, the range is [100, 1000]."},
+	{"getMaxIter", (PyCFunction) Radio_get_maxiter, METH_NOARGS,
+		"() - Get maximum number of radiosity rounds."},
+	{"setMaxIter", (PyCFunction) Radio_set_maxiter, METH_VARARGS,
+		"(i) - Set maximum number of radiosity rounds in [0, 10000]."},
+	{"getSubShPatch", (PyCFunction) Radio_get_subshootp, METH_NOARGS,
+		"() - Get max number of times environment is tested to detect patches."},
+	{"setSubShPatch", (PyCFunction) Radio_set_subshootp, METH_VARARGS,
+		"(i) - Set max number of times environment is tested to detect patches.\n\
+	Range is [0, 10]."},
+	{"getSubShElem", (PyCFunction) Radio_get_subshoote, METH_NOARGS,
+		"() - Get number of times environment is tested to detect elements."},
+	{"setSubShElem", (PyCFunction) Radio_set_subshoote, METH_VARARGS,
+		"(i) - Set number of times environment is tested to detect elements.\n\
+	Range is [0, 10]."},
+	{"getNodeLimit", (PyCFunction) Radio_get_nodelim, METH_NOARGS,
+		"() - Get the range for removing doubles."},
+	{"setNodeLimit", (PyCFunction) Radio_set_nodelim, METH_VARARGS,
+		"(i) - Set the range for removing doubles in [0, 50]."},
+	{"getMaxSubDivSh", (PyCFunction) Radio_get_maxsublamp, METH_NOARGS,
+		"() - Get max number of initial shoot patches evaluated."},
+	{"setMaxSubDivSh", (PyCFunction) Radio_set_maxsublamp, METH_VARARGS,
+		"(i) - Set max number of initial shoot patches evaluated in [1, 250]."},
+	{"getPatchMax", (PyCFunction) Radio_get_pama, METH_NOARGS,
+		"() - Get max size of a patch."},
+	{"setPatchMax", (PyCFunction) Radio_set_pama, METH_VARARGS,
+		"(i) - Set max size of a patch in [10, 1000]."},
+	{"getPatchMin", (PyCFunction) Radio_get_pami, METH_NOARGS,
+		"() - Get minimum size of a patch."},
+	{"setPatchMin", (PyCFunction) Radio_set_pami, METH_VARARGS,
+		"(i) - Set minimum size of a patch in [10, 1000]."},
+	{"getElemMax", (PyCFunction) Radio_get_elma, METH_NOARGS,
+		"() - Get max size of an element."},
+	{"setElemMax", (PyCFunction) Radio_set_elma, METH_VARARGS,
+		"(i) - Set max size of an element in [1, 100]."},
+	{"getElemMin", (PyCFunction) Radio_get_elmi, METH_NOARGS,
+		"() - Get minimum size of an element."},
+	{"setElemMin", (PyCFunction) Radio_set_elmi, METH_VARARGS,
+		"(i) - Set minimum size of an element in [1, 100]."},
+	{"getMaxElems", (PyCFunction) Radio_get_maxnode, METH_NOARGS,
+		"() - Get maximum number of elements."},
+	{"setMaxElems", (PyCFunction) Radio_set_maxnode, METH_VARARGS,
+		"(i) - Set maximum nunber of elements in [1, 250000]."},
+	{"getConvergence", (PyCFunction) Radio_get_convergence, METH_NOARGS,
+		"() - Get lower threshold of unshot energy."},
+	{"setConvergence", (PyCFunction) Radio_set_convergence, METH_VARARGS,
+		"(f) - Set lower threshold of unshot energy in [0.0, 1.0]."},
+	{"getMult", (PyCFunction) Radio_get_radfac, METH_NOARGS,
+		"() - Get energy value multiplier."},
+	{"setMult", (PyCFunction) Radio_set_radfac, METH_VARARGS,
+		"(f) - Set energy value multiplier in [0.001, 250.0]."},
+	{"getGamma", (PyCFunction) Radio_get_gamma, METH_NOARGS,
+		"() - Get change in the contrast of energy values."},
+	{"setGamma", (PyCFunction) Radio_set_gamma, METH_VARARGS,
+		"(f) - Set change in the contrast of energy values in [0.2, 10.0]."},
+	{"getDrawType", (PyCFunction) Radio_get_drawtype, METH_NOARGS,
+		"() - Get the draw type: Wire, Solid or Gouraud as an int value."},
+	{"setDrawType", (PyCFunction) Radio_set_drawtype, METH_VARARGS,
+		"(i or s) - Set the draw type: wire, solid (default) or gouraud."},
+	{"getMode", (PyCFunction) Radio_get_flag, METH_NOARGS,
+		"() - Get mode as an or'ed bitmask, see Radio.Modes dict."},
+	{"setMode", (PyCFunction) Radio_set_flag, METH_VARARGS,
+		"(|ss) - Set mode flags as strings: 'ShowLimits', 'Z'."},
+	{NULL, NULL, 0, NULL}
+};
+
+static PyTypeObject Radio_Type = {
+	PyObject_HEAD_INIT(NULL)
+	0, /*ob_size*/
+	"Blender Radiosity", /*tp_name*/
+	sizeof(BPy_Radio), /*tp_basicsize*/
+	0, /*tp_itemsize*/
+	(destructor)Radio_dealloc, /*tp_dealloc*/
+	0, /*tp_print*/
+	0, /*tp_getattr*/
+	0, /*tp_setattr*/
+	0, /*tp_compare*/
+	(reprfunc)Radio_repr, /*tp_repr*/
+	0, /*tp_as_number*/
+	0, /*tp_as_sequence*/
+	0, /*tp_as_mapping*/
+	0, /*tp_hash */
+	0, /*tp_call*/
+	0, /*tp_str*/
+	0, /*tp_getattro*/
+	0, /*tp_setattro*/
+	0, /*tp_as_buffer*/
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
+	"Blender radiosity", /* tp_doc */
+	0, /* tp_traverse */
+	0, /* tp_clear */
+	0, /* tp_richcompare */
+	0, /* tp_weaklistoffset */
+	0, /* tp_iter */
+	0, /* tp_iternext */
+	BPy_Radio_methods, /* tp_methods */
+	0, /* tp_members */
+	0, /* tp_getset */
+	0, /* tp_base */
+	0, /* tp_dict */
+	0, /* tp_descr_get */
+	0, /* tp_descr_set */
+	0, /* tp_dictoffset */
+	0, /* tp_init */
+	0, /* tp_alloc */
+	0, /* tp_new */
+	0,0,0,0,0,0,0,0, /* up to tp_del, so we don't get a warning */
+};
+
+static void Radio_dealloc (BPy_Radio *self)
+{
+		PyObject_DEL (self);
+}
+
+static PyObject *Radio_repr (BPy_Radio *self)
+{
+	if (self->radio)
+		return PyString_FromFormat ("[Radiosity \"%s\"]", self->scene->id.name + 2);
+	else
+		return PyString_FromString ("NULL");
+}
+
+PyObject *Radio_CreatePyObject (struct Scene *scene)
+{
+	BPy_Radio *py_radio;
+
+	if (scene != G.scene) {
+		return EXPP_ReturnPyObjError (PyExc_EnvironmentError,
+		"\nradiosity only works on the current scene, check scene.makeCurrent().");
+	}
+
+	py_radio = (BPy_Radio *) PyObject_NEW (BPy_Radio, &Radio_Type);
+
+	if (!py_radio) return NULL;
+
+	if (!scene->radio) add_radio(); /* adds to G.scene */
+
+	py_radio->radio = scene->radio;
+	py_radio->scene = scene;
+
+	return ((PyObject *) py_radio);
+}
+
+int Radio_CheckPyObject (PyObject *pyob)
+{
+	return (pyob->ob_type == &Radio_Type);
+}
+
+static PyObject *Radio_collectMeshes(BPy_Radio *self)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+
+	disable_where_script(1); /* used to avoid error popups */
+	rad_collect_meshes();
+	disable_where_script(0);
+
+	return EXPP_incr_ret(Py_None);
+}
+
+static PyObject *Radio_freeData(BPy_Radio *self)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+
+	delete_radio();
+
+	return EXPP_incr_ret(Py_None);
+}
+
+static PyObject *Radio_go(BPy_Radio *self)
+{
+	if (!EXPP_check_scene(self->scene)) return NULL;
+
+	rad_go();
+
+	return EXPP_incr_ret(Py_None);
+}
+
+static PyMethodDef M_Radio_methods[] = {{NULL, NULL, 0, NULL}};
+
+PyObject *Radio_Init (void)
+{
+	PyObject *submodule, *Modes, *DrawTypes;
+
+	if (PyType_Ready(&Radio_Type) < 0) return NULL;
+
+	submodule = Py_InitModule3 ("Blender.Scene.Radio", M_Radio_methods,
+		"The Blender Radiosity submodule");
+
+	Modes = M_constant_New();
+	DrawTypes = M_constant_New();
+
+	if (Modes) {
+		BPy_constant *d = (BPy_constant *)Modes;
+
+		constant_insert(d, "ShowLimits", PyInt_FromLong(EXPP_RADIO_flag_SHOWLIM));
+		constant_insert(d, "Z", PyInt_FromLong(EXPP_RADIO_flag_Z));
+
+		PyModule_AddObject(submodule, "Modes", Modes);
+	}
+
+	if (DrawTypes) {
+		BPy_constant *d = (BPy_constant *)DrawTypes;
+
+		constant_insert(d, "Wire", PyInt_FromLong(EXPP_RADIO_drawtype_WIRE));
+		constant_insert(d, "Solid", PyInt_FromLong(EXPP_RADIO_drawtype_SOLID));
+		constant_insert(d, "Gouraud", PyInt_FromLong(EXPP_RADIO_drawtype_GOURAUD));
+
+		PyModule_AddObject(submodule, "DrawTypes", DrawTypes);
+	}
+
+	return submodule;
+}