blender-archive/source/blender/bpython/intern/BPY_ipo.c

/** Ipo module; access to Ipo datablocks in Blender
  * $Id$
 *
 * ***** 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.
 *
 * The Original Code is: all of this file.
 *
 * Contributor(s): none yet.
 *
 * ***** END GPL/BL DUAL LICENSE BLOCK *****
  *
  */
#include "MEM_guardedalloc.h"

#include "Python.h"
#include "BPY_macros.h"
#include "BPY_tools.h"

#include "b_interface.h" // most datatypes

#include "opy_datablock.h"

#include "DNA_curve_types.h"

#include "BSE_editipo.h"

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

/* GLOBALS */

/* These should be put into a proper dictionary for quicker retrieval..*/

NamedEnum g_OB_ipocodes[] = {

	{ "LocX",   OB_LOC_X },
	{ "LocY",   OB_LOC_Y },
	{ "LocZ",   OB_LOC_Z },
	{ "dLocX",  OB_DLOC_X },
	{ "dLocY",  OB_DLOC_Y },
	{ "dLocZ",  OB_DLOC_Z },
	{ "RotX",   OB_ROT_X },
	{ "RotY",   OB_ROT_Y },
	{ "RotZ",   OB_ROT_Z },
	{ "dRotX",  OB_DROT_X },
	{ "dRotY",  OB_DROT_Y },
	{ "dRotZ",  OB_DROT_Z },
	{ "SizeX",  OB_SIZE_X },
	{ "SizeY",  OB_SIZE_Y },
	{ "SizeY",  OB_SIZE_Z },
	{ "dSizeX", OB_DSIZE_X },
	{ "dSizeY", OB_DSIZE_Y },
	{ "dSizeY", OB_DSIZE_Z },
	{ "Layer",  OB_LAY },
	{ "Time",   OB_TIME },
	{ 0, 0 }
};

NamedEnum g_MA_ipocodes[] = {

	{ "R",      MA_COL_R },
	{ "G",      MA_COL_G },
	{ "B",      MA_COL_B },
	{ "Alpha",  MA_ALPHA},
	{ "SpecR",  MA_SPEC_R },
	{ "SpecG",  MA_SPEC_G },
	{ "SpecB",  MA_SPEC_B },
	{ "MirR",   MA_MIR_R },
	{ "MirG",   MA_MIR_G },
	{ "MirB",   MA_MIR_B },
	{ "Emit",   MA_EMIT },
	{ "Amb",    MA_AMB },
	{ "Spec",   MA_SPEC },
	{ "Hard",   MA_HARD },
	{ "SpTra",  MA_SPTR },
	{ "Ang",    MA_ANG },
	{ "HaSize", MA_HASIZE },
	{ 0, 0 }
};

NamedEnum g_WO_ipocodes[] = {
	{ "HorR",   WO_HOR_R },
	{ "HorG",   WO_HOR_G },
	{ "HorB",   WO_HOR_B },
	{ "ZenR",   WO_ZEN_R },
	{ "ZenG",   WO_ZEN_G },
	{ "ZenB",   WO_ZEN_B },
	{ "Expos",  WO_EXPOS },
	{ "Misi",   WO_MISI },
	{ "MisDi",  WO_MISTDI },
	{ "MisSta", WO_MISTSTA },
	{ "MisHi",  WO_MISTHI },
	{ "StarR",  WO_STAR_R },
	{ "StarG",  WO_STAR_G },
	{ "StarB",  WO_STAR_B },
	{ "StarDi", WO_STARDIST },
	{ "StarSi", WO_STARSIZE },
	{ 0, 0 }
};

NamedEnum g_CA_ipocodes[] = {
	{ "Lens",  CAM_LENS },
	{ "ClSta", CAM_STA },
	{ "ClEnd", CAM_END },
	{ 0, 0 }
};

PyObject *g_ipoBlockTypes;           // global for ipo type container
PyObject *g_interpolationTypes; // global for interpolation type container
PyObject *g_extrapolationTypes; // global for extrapolation type container

typedef struct _PyBezTriple {
	PyObject_VAR_HEAD
	
	BezTriple bzt;
} PyBezTriple;


void pybzt_dealloc(PyObject *self) {
	PyMem_DEL(self);
}

PyObject *pybzt_repr(PyObject *self) {
	return PyString_FromString("[BezTriple]");
}

/* XXX */

NamedEnum bez_triple_flags[]= {
	{"Free", HD_FREE},
	{"Auto", HD_AUTO},
	{"Vect", HD_VECT},
	{"Align", HD_ALIGN},
	{NULL}
};

DataBlockProperty BezTriple_Properties[]= {
	{"h1", 	"vec[3][3]", 	DBP_TYPE_VEC, 0, 2.0, 0.0, {0,0}, {3,3,-sizeof(float)}}, 
	{"pt", 	"vec[3][3]", 	DBP_TYPE_VEC, 0, 2.0, 0.0, {1,0}, {3,3,-sizeof(float)}}, 
	{"h2", 	"vec[3][3]", 	DBP_TYPE_VEC, 0, 2.0, 0.0, {2,0}, {3,3,-sizeof(float)}}, 
	
	{"f1", 	"f1", 			DBP_TYPE_CHA, 0, 0.0, 1.0},
	{"f2", 	"f2", 			DBP_TYPE_CHA, 0, 0.0, 1.0},
	{"f3", 	"f3", 			DBP_TYPE_CHA, 0, 0.0, 1.0},

	{"h1Type", "h1", 		DBP_TYPE_SHO, 0, 0.0, 0.0, {0}, {0}, DBP_HANDLING_NENM, bez_triple_flags},
	{"h2Type", "h2", 		DBP_TYPE_SHO, 0, 0.0, 0.0, {0}, {0}, DBP_HANDLING_NENM, bez_triple_flags},

	{"h1t", "h1", 			DBP_TYPE_SHO, 0, 0.0, 0.0, {0}, {0}, DBP_HANDLING_NENM, bez_triple_flags},
	{"h2t", "h2", 			DBP_TYPE_SHO, 0, 0.0, 0.0, {0}, {0}, DBP_HANDLING_NENM, bez_triple_flags},
	
	{NULL}
};

PyObject *pybzt_getattr(PyObject *self, char *name) {
	PyBezTriple *pybzt= (PyBezTriple *) self;

	return datablock_getattr(BezTriple_Properties, "BezTriple", name, &pybzt->bzt);
}

int pybzt_setattr(PyObject *self, char *name, PyObject *ob) {
	PyBezTriple *pybzt= (PyBezTriple *) self;

	return datablock_setattr(BezTriple_Properties, "BezTriple", name, &pybzt->bzt, ob);
}

PyTypeObject PyBezTriple_Type = {
	PyObject_HEAD_INIT(NULL)
	0,								/*ob_size*/
	"BezTriple",					/*tp_name*/
	sizeof(PyBezTriple),			/*tp_basicsize*/
	0,								/*tp_itemsize*/
	/* methods */
	(destructor)	pybzt_dealloc,	/*tp_dealloc*/
	(printfunc)		0,	/*tp_print*/
	(getattrfunc)	pybzt_getattr,	/*tp_getattr*/
	(setattrfunc)	pybzt_setattr,	/*tp_setattr*/
	0,								/*tp_compare*/
	(reprfunc) pybzt_repr,								/*tp_repr*/
	0,								/*tp_as_number*/
	0,								/*tp_as_sequence*/
	0,								/*tp_as_mapping*/
	0,								/*tp_hash*/	
};

static char pybzt_create_doc[]= "() - Create a new BezTriple object";
PyObject *pybzt_create(PyObject *self, PyObject *args) {
	PyBezTriple *py_bzt= PyObject_NEW(PyBezTriple, &PyBezTriple_Type);
	// BezTriple *bzt= &py_bzt->bzt;
	
	BPY_TRY(PyArg_ParseTuple(args, ""));
	
	memset(&py_bzt->bzt,0,sizeof(py_bzt->bzt));
	
	return (PyObject *) py_bzt;
}

PyObject *pybzt_from_bzt(BezTriple *bzt) {
	PyBezTriple *py_bzt= PyObject_NEW(PyBezTriple, &PyBezTriple_Type);
	
	memcpy(&py_bzt->bzt, bzt, sizeof(*bzt));
	
	return (PyObject *) py_bzt;
}


typedef struct _PyIpoCurve {
	PyObject_VAR_HEAD

	IpoCurve *icu;
} PyIpoCurve;


/********************/
/* IpoCurve methods */

#undef MethodDef
#define MethodDef(func) _MethodDef(func, IpoCurve)

#define DICT_FROM_CONSTDICT(x) \
	((constobject *) x)->dict

/** sets an enum int value 'by name' from the dictionary dict */

static PyObject *setEnum_fromDict(short *i, PyObject *dict, char *key, char *errmsg)
{
	PyObject *p;
	p = PyDict_GetItemString(dict, key);
	if (!p) {
		PyErr_SetString(PyExc_TypeError, errmsg);
		return NULL;
	}

	*i = (short) PyInt_AsLong(p);
	return BPY_incr_ret(Py_None);
}

static char IpoCurve_setInterpolation_doc[] = 
"(type) - Set interpolation to one of: ['Constant', 'Linear', 'Bezier']";

static PyObject *IpoCurve_setInterpolation(PyObject *self, PyObject *args)
{
	char *typename;
	IpoCurve *ipocurve = (IpoCurve *) ((PyIpoCurve *) self)->icu;

	BPY_TRY(PyArg_ParseTuple(args, "s", &typename));

	return setEnum_fromDict(&ipocurve->ipo, DICT_FROM_CONSTDICT(g_interpolationTypes),
		typename, "Improper interpolation type, see Ipo.InterpolationTypes");

}

static char IpoCurve_setExtrapolation_doc[] = 
"(type) - Set interpolation to one of: ['Constant', 'Linear', 'Cyclic', 'CyclicLinear']";

static PyObject *IpoCurve_setExtrapolation(PyObject *self, PyObject *args)
{
	char *typename;
	IpoCurve *ipocurve = (IpoCurve *) ((PyIpoCurve *) self)->icu;

	BPY_TRY(PyArg_ParseTuple(args, "s", &typename));


	return setEnum_fromDict(&ipocurve->extrap, DICT_FROM_CONSTDICT(g_extrapolationTypes), 
		typename, "Improper extrapolation type, see Ipo.ExtrapolationTypes");
}

static char IpoCurve_getInterpolation_doc[] = 
"() - Returns interpolation type";

static PyObject *IpoCurve_getInterpolation(PyObject *self, PyObject *args)
{
	IpoCurve *ipocurve = (IpoCurve *) ((PyIpoCurve *) self)->icu;

	switch (ipocurve->ipo) {
	case IPO_CONST:	return PyString_FromString("Constant");
	case IPO_LIN:	return PyString_FromString("Linear");
	case IPO_BEZ:	return PyString_FromString("Bezier");			
	default:        return PyString_FromString("<not defined>"); 
	}
}

static char IpoCurve_getExtrapolation_doc[] = 
"() - Returns extrapolation type";

static PyObject *IpoCurve_getExtrapolation(PyObject *self, PyObject *args)
{
	IpoCurve *ipocurve = (IpoCurve *) ((PyIpoCurve *) self)->icu;

	switch (ipocurve->extrap) {
	case IPO_HORIZ:	return PyString_FromString("Constant");
	case IPO_DIR:	return PyString_FromString("Linear");
	case IPO_CYCL:	return PyString_FromString("Cyclic");					
	case IPO_CYCLX:	return PyString_FromString("CyclicLinear");					
	default:        return PyString_FromString("<not defined>"); 
	}

}

static char IpoCurve_eval_doc[] = 
"(time = <current frame>) - evaluates ipo at time 'time' and returns result\n\
(float). If 'time' is not specified, the current frame value is taken";

static PyObject *IpoCurve_eval(PyObject *self, PyObject *args)
{
	PyIpoCurve *pIpocurve = (PyIpoCurve *) self;
	float time = CurrentFrame;

	BPY_TRY(PyArg_ParseTuple(args, "|f", &time));
	
	return PyFloat_FromDouble(eval_icu(pIpocurve->icu, time));
}

static char IpoCurve_update_doc[] = 
"() - update and recalculate IpoCurve";

static PyObject *IpoCurve_update(PyObject *self, PyObject *args)
{

	BPY_TRY(PyArg_ParseTuple(args, ""));

	testhandles_ipocurve(((PyIpoCurve *) self)->icu); // recalculate IPO

	Py_INCREF(Py_None);
	return Py_None;
}

static struct PyMethodDef IpoCurve_methods[] = {
	MethodDef(setInterpolation), 
	MethodDef(getInterpolation), 
	MethodDef(setExtrapolation), 
	MethodDef(getExtrapolation), 
	MethodDef(eval), 
	MethodDef(update), 
	{NULL, NULL}
};


PyObject *IpoCurve_getattr(PyObject *self, char *name) {
	PyIpoCurve *py_icu= (PyIpoCurve *) self;
	IpoCurve *icu= py_icu->icu;

	if (STREQ(name, "type")) {
		return IpoCurve_getInterpolation(self, Py_BuildValue(""));
	} else if (STREQ(name, "extend")) {
		return IpoCurve_getExtrapolation(self, Py_BuildValue(""));
	} else if (STREQ(name, "name")) {
		char icu_name[32]= "";
		
		switch (icu->blocktype) {
		case ID_OB:
			getname_ob_ei(icu->adrcode, icu_name, 0);
			break;
		case ID_MA:
			getname_mat_ei(icu->adrcode, icu_name);
			break;
		case ID_WO:
			getname_world_ei(icu->adrcode, icu_name);
			break;
		case ID_SEQ:
			getname_seq_ei(icu->adrcode, icu_name);
			break;
		case ID_CU:
			getname_cu_ei(icu->adrcode, icu_name);
			break;
		case ID_KE:
			getname_key_ei(icu->adrcode, icu_name);
			break;
		case ID_LA:
			getname_la_ei(icu->adrcode, icu_name);
			break;
		case ID_CA:
			getname_cam_ei(icu->adrcode, icu_name);
			break;
		default:
			return PyString_FromString("<unknown>");
		}
		
		return PyString_FromString(icu_name);
	} else if (STREQ(name, "points")) {
		PyObject *list= PyList_New(icu->totvert);
		BezTriple *bzt= icu->bezt;
		int i;
		
		for (i=0; i<icu->totvert; i++) {
			PyList_SetItem(list, i, pybzt_from_bzt(bzt));
			bzt++;
		}
		
		return list;
	} 
	return Py_FindMethod(IpoCurve_methods, (PyObject*)self, name);
}

int IpoCurve_setattr(PyObject *self, char *name, PyObject *ob) {
	PyIpoCurve *py_icu= (PyIpoCurve *) self;
	IpoCurve *icu= py_icu->icu;

	if (STREQ(name, "points")) {
		int i, len;
		BezTriple *bzt;
		
		if (!PySequence_Check(ob) || !BPY_check_sequence_consistency(ob, &PyBezTriple_Type))
			return py_err_ret_int(PyExc_AttributeError, "Expected list of BezTriples");

		len= PySequence_Length(ob);

		if (icu->bezt) // free existing (IF)
			MEM_freeN(icu->bezt);

		icu->totvert= len;
		if (len) icu->bezt= MEM_mallocN(len*sizeof(BezTriple), "beztriples");
		
		bzt= icu->bezt;
		for (i=0; i<len; i++) {
			PyBezTriple *pybzt= (PyBezTriple*) PySequence_GetItem(ob, i);
			
			memcpy(bzt, &pybzt->bzt, sizeof(BezTriple));
			bzt++;
			
			Py_DECREF(pybzt);
		}

		/* Twice for auto handles */
		calchandles_ipocurve(icu);
		calchandles_ipocurve(icu);

		boundbox_ipocurve(icu);
		sort_time_ipocurve(icu);
		
		return 0;
	}

	PyErr_SetString(PyExc_AttributeError, name);
	return -1;	
}

void IpoCurve_dealloc(PyObject *self) {
	PyMem_DEL(self);
}

PyObject *IpoCurve_repr(PyObject *self) {
	char s[256];
	sprintf (s, "[IpoCurve %.32s]", 
	         PyString_AsString(IpoCurve_getattr(self, "name")));
	return Py_BuildValue("s", s);
}

PyTypeObject PyIpoCurve_Type = {
	PyObject_HEAD_INIT(NULL)
	0,								/*ob_size*/
	"IpoCurve",						/*tp_name*/
	sizeof(PyIpoCurve),				/*tp_basicsize*/
	0,								/*tp_itemsize*/
	/* methods */
	(destructor)	IpoCurve_dealloc,	/*tp_dealloc*/
	(printfunc)		0,	/*tp_print*/
	(getattrfunc)	IpoCurve_getattr,	/*tp_getattr*/
	(setattrfunc)	IpoCurve_setattr,	/*tp_setattr*/
	0,								/*tp_compare*/
	(reprfunc) IpoCurve_repr,		/*tp_repr*/
	0,								/*tp_as_number*/
	0,								/*tp_as_sequence*/
	0,								/*tp_as_mapping*/
	0,								/*tp_hash*/	
};

PyObject *IpoCurve_from_icu(IpoCurve *icu) {
	PyIpoCurve *ob= PyObject_NEW(PyIpoCurve, &PyIpoCurve_Type);
	
	ob->icu= icu;
	
	return (PyObject *) ob;
}

PyObject *make_icu_list (ListBase *curves) {
	ListBase lb= *curves;
	IpoCurve *icu= (IpoCurve *) lb.first;
	PyObject *list= PyList_New(0);
	PyObject *pyipo;
	
	while (icu) {
		pyipo = IpoCurve_from_icu(icu);
		PyList_Append(list, pyipo);
		Py_DECREF(pyipo);
		icu= icu->next;
	}
	
	return list;	
}

DataBlockProperty Ipo_Properties[]= {
	{"curves", "curve", DBP_TYPE_FUN, 0, 0.0, 0.0, {0}, {0}, 0, 0, make_icu_list}, 
	{NULL}	
};


/**********************/
/* Ipo module methods */

DATABLOCK_GET(Ipomodule, ipo, getIpoList())

static char Ipomodule_New_doc[] = 
"(type, name = <default>) - Creates a new Ipo block of the specified type,\n\
which must be of the appropriate datablock ID type (e.g. ID_OB, ID_MA, ...)";


static PyObject *Ipomodule_New(PyObject *self, PyObject *args)
{
	Ipo *ipo;
	int type;
	PyObject *p;
	char *name = NULL, *typename;

	BPY_TRY(PyArg_ParseTuple(args, "s|s", &typename, &name));
	p = PyDict_GetItemString(((constobject *)g_ipoBlockTypes)->dict, typename);
	if (!p) {
		PyErr_SetString(PyExc_TypeError, "Improper Ipo type, see Ipo.Types");
		return NULL;
	}
		
	type = PyInt_AsLong(p);

	if (!name) {
		switch(type) {
			case ID_OB: name = "Objpo"; break;
			case ID_MA: name = "MatIpo"; break;
			case ID_SEQ: name = "SeqIpo"; break;
			case ID_CU: name = "CurveIpo"; break;
			case ID_KE: name = "KeyIpo"; break;
			case ID_WO: name = "WorldIpo"; break;
			case ID_LA: name = "LampIpo"; break;
			case ID_CA: name = "CamIpo"; break;
			case ID_SO: name = "SndIpo"; break;
			case ID_AC: name = "ActionIpo"; break;
			default:
				PyErr_SetString(PyExc_TypeError, "Internal error, illegal type");
				return NULL;
		}		
	}		

	ipo = ipo_new(type, name);
	return DataBlock_fromData(ipo);
}

#undef MethodDef
#define MethodDef(func) _MethodDef(func, Ipomodule)
struct PyMethodDef Ipomodule_methods[] = {

	MethodDef(New),
	MethodDef(get),
	{"BezTriple", pybzt_create, METH_VARARGS, pybzt_create_doc},
	
	{NULL, NULL}
};

/********************/
/* Ipoblock methods */

/* slow and inefficient lookup function , use proper dictionaries in future */
short code_lookup(NamedEnum *codetab, char *name)
{
	int i = 0;
	
	while(codetab[i].name)
	{
		if (!strcmp(codetab[i].name, name))
			return codetab[i].num;
		i++;		
	}	
	return -1;
}

static char Ipo_addCurve_doc[]=
"(type, curve = None) - adds IpoCurve 'curve' to the IpoBlock under type id 'type'";
PyObject *Ipo_addCurve(PyObject *self, PyObject *args) 
{
	
	Ipo *ipo = (Ipo *) ((DataBlock *) self)->data;
	NamedEnum *lookup;

	short code;

	char *type;
	PyIpoCurve *curve = NULL;
	IpoCurve *ipocurve, *existingIpoCurve;

	BPY_TRY(PyArg_ParseTuple(args, "s|O!", &type, &PyIpoCurve_Type, &curve));

	switch (ipo->blocktype) {
	case ID_OB:
		lookup = g_OB_ipocodes;
		break;
	case ID_CA:
		lookup = g_CA_ipocodes;
		break;
	case ID_MA:
		lookup = g_MA_ipocodes;
		break;
	case ID_WO:
		lookup = g_WO_ipocodes;
		break;
	default:
		PyErr_SetString(PyExc_TypeError, "Ipo type not (YET) supported");
		return NULL;
	}
	code = code_lookup(lookup, type);
	if (code == -1) {
		PyErr_SetString(PyExc_TypeError, "Unknown IpoCurve type");
		return NULL;
	}	

	if (!curve) {                             
		ipocurve = ipocurve_new();            // malloc new ipocurve
	} else {                                  // add existing curve:
		ipocurve = ipocurve_copy(curve->icu); // copy ipocurve
	}

	ipocurve->adrcode = code;             // re-code ipo
	ipocurve->blocktype = ipo->blocktype;  

	existingIpoCurve = ipo_findcurve(ipo, code);
	if (existingIpoCurve) {
		BLI_remlink(&(ipo->curve), existingIpoCurve); // remove existing
		MEM_freeN(existingIpoCurve);
	}
	BLI_addtail(&(ipo->curve), ipocurve); // add curve to list
	return IpoCurve_from_icu(ipocurve);
}

static char Ipo_update_doc[]=
"() - Recalculate the ipo and update linked objects";

PyObject *Ipo_update(PyObject *self, PyObject *args) {
	DataBlock *ipoblock = (DataBlock *) self;
	Key *key;
	
	do_ipo((Ipo *) ipoblock->data);

	/* here we should signal all objects with keys that the ipo changed */
	
	key= getKeyList()->first;
	while(key) {
		if(key->ipo == (Ipo *)ipoblock->data) do_spec_key(key);
		key= key->id.next;
	}
	
	return BPY_incr_ret(Py_None);
}

#undef MethodDef
#define MethodDef(func) _MethodDef(func, Ipo)
struct PyMethodDef Ipo_methods[] = {
	MethodDef(addCurve),
	MethodDef(update),
	{NULL, NULL}
};


PyObject *initIpo(void)
{
	PyObject *mod, *dict, *d;

	mod= Py_InitModule(MODNAME(BLENDERMODULE) ".Ipo", Ipomodule_methods);
	dict = PyModule_GetDict(mod);

	// ipo block types
	d = ConstObject_New();
	PyDict_SetItemString(dict, "Types", d);
	g_ipoBlockTypes = d;

	insertConst(d, "Object", PyInt_FromLong(ID_OB));
	insertConst(d, "Material", PyInt_FromLong(ID_MA));
	insertConst(d, "Sequence", PyInt_FromLong(ID_SEQ));
	insertConst(d, "Curve", PyInt_FromLong(ID_CU));
	insertConst(d, "Key", PyInt_FromLong(ID_KE));
	insertConst(d, "World", PyInt_FromLong(ID_WO));
	insertConst(d, "Lamp", PyInt_FromLong(ID_LA));
	insertConst(d, "Camera", PyInt_FromLong(ID_CA));
	insertConst(d, "Sound", PyInt_FromLong(ID_SO));
	insertConst(d, "Action", PyInt_FromLong(ID_AC));

	// interpolation types:
	d = ConstObject_New();
	g_interpolationTypes = d;
	PyDict_SetItemString(dict, "InterpolationTypes", d);
	insertConst(d, "Constant", PyInt_FromLong(IPO_CONST));
	insertConst(d, "Linear", PyInt_FromLong(IPO_LIN));
	insertConst(d, "Bezier", PyInt_FromLong(IPO_BEZ));

	d = ConstObject_New();
	g_extrapolationTypes = d;
	PyDict_SetItemString(dict, "ExtrapolationTypes", d);
	insertConst(d, "Constant", PyInt_FromLong(IPO_HORIZ));
	insertConst(d, "Linear", PyInt_FromLong(IPO_DIR));
	insertConst(d, "Cyclic", PyInt_FromLong(IPO_CYCL));
	insertConst(d, "CyclicLinear", PyInt_FromLong(IPO_CYCLX));

	return mod;
}