Page MenuHome
Files F2271

patch-beztriple-v0.1.txt
Public
Actions

Authored By
Ken Hughes (khughes)
Nov 13 2013, 1:03 PM
Size
22 KB
Subscribers
None

patch-beztriple-v0.1.txt
View Options

Index: blender/source/blender/python/api2_2x/BezTriple.c
===================================================================
RCS file: /cvsroot/bf-blender/blender/source/blender/python/api2_2x/BezTriple.c,v
retrieving revision 1.10
diff -u -u -r1.10 BezTriple.c
--- blender/source/blender/python/api2_2x/BezTriple.c 7 Oct 2004 19:25:39 -0000 1.10
+++ blender/source/blender/python/api2_2x/BezTriple.c 1 Jun 2005 05:51:32 -0000
@@ -24,7 +24,7 @@
*
* This is a new part of Blender.
*
- * Contributor(s): Jacques Guignot
+ * Contributor(s): Jacques Guignot, Ken Hughes
*
* ***** END GPL/BL DUAL LICENSE BLOCK *****
*/
@@ -42,23 +42,28 @@
#include "constant.h"
#include "gen_utils.h"
-
+#include "Types.h"
/*****************************************************************************/
/* Python API function prototypes for the BezTriple module. */
/*****************************************************************************/
+#if 0
static PyObject *M_BezTriple_New( PyObject * self, PyObject * args );
static PyObject *M_BezTriple_Get( PyObject * self, PyObject * args );
+#endif
/*****************************************************************************/
-/* Python C_BezTriple instance methods declarations: */
+/* Python C_BezTriple instance methods declarations: */
/*****************************************************************************/
static PyObject *BezTriple_setPoints( C_BezTriple * self, PyObject * args );
static PyObject *BezTriple_getPoints( C_BezTriple * self );
static PyObject *BezTriple_getTriple( C_BezTriple * self );
+static PyObject *BezTriple_setTriple( C_BezTriple * self, PyObject * args);
+static PyObject *BezTriple_getHandle( C_BezTriple * self );
+static PyObject *BezTriple_setHandle( C_BezTriple * self, PyObject * args );
/*****************************************************************************/
-/* Python BezTriple_Type callback function prototypes: */
+/* Python BezTriple_Type callback function prototypes: */
/*****************************************************************************/
static void BezTripleDeAlloc( C_BezTriple * self );
static int BezTripleSetAttr( C_BezTriple * self, char *name, PyObject * v );
@@ -66,14 +71,22 @@
static PyObject *BezTripleRepr( C_BezTriple * self );
/*****************************************************************************/
+/* Python BezTriple utility function prototypes: */
+/*****************************************************************************/
+static PyObject *generate_ModuleIntConstant(char *name, int value, char *doc);
+static PyObject *return_ModuleConstant( char *constant_name);
+
+/*****************************************************************************/
/* Python method structure definition for Blender.BezTriple module: */
/*****************************************************************************/
struct PyMethodDef M_BezTriple_methods[] = {
+#if 0
{"New", ( PyCFunction ) M_BezTriple_New, METH_VARARGS | METH_KEYWORDS,
0},
{"Get", M_BezTriple_Get, METH_VARARGS, 0},
{"get", M_BezTriple_Get, METH_VARARGS, 0},
+#endif
{NULL, NULL, 0, NULL}
};
@@ -88,6 +101,12 @@
"() - return BezTriple knot point x and y coordinates"},
{"getTriple", ( PyCFunction ) BezTriple_getTriple, METH_NOARGS,
"() - return list of 3 floating point triplets. order is H1, knot, H2"},
+ {"setTriple", ( PyCFunction ) BezTriple_setTriple, METH_VARARGS,
+ "(list of 3 floating point triplets) - order is H1, knot, H2"},
+ {"getHandle", ( PyCFunction ) BezTriple_getHandle, METH_NOARGS,
+ "() - return list of two module constants, handle settings H1 H2"},
+ {"setHandle", ( PyCFunction ) BezTriple_setHandle, METH_VARARGS,
+ "() - set handle H1 and H2 using module constants"},
{NULL, NULL, 0, NULL}
};
@@ -121,7 +140,7 @@
0
};
-
+#if 0
/*****************************************************************************/
/* Function: M_BezTriple_New */
/* Python equivalent: Blender.BezTriple.New */
@@ -143,6 +162,7 @@
{
return 0;
}
+#endif
/*****************************************************************************/
/* Function: BezTripleDeAlloc */
@@ -154,79 +174,177 @@
PyObject_DEL( self );
}
-static PyObject *BezTriple_getPoints( C_BezTriple * self )
+/*****************************************************************************/
+/* Function: BezTripleGetAttr */
+/* Description: This is a callback function for the C_BezTriple type. It */
+/* taccesses C_BezTriple "member variables" and methods. */
+/*****************************************************************************/
+static PyObject *BezTripleGetAttr( C_BezTriple * self, char *name )
{
- struct BezTriple *bezt = self->beztriple;
- PyObject *l = PyList_New( 0 );
- int i;
- for( i = 0; i < 2; i++ ) {
- PyList_Append( l, PyFloat_FromDouble( bezt->vec[1][i] ) );
+ if( strcmp( name, "pt" ) == 0 )
+ return BezTriple_getPoints( self );
+ else if( strcmp( name, "vec" ) == 0 )
+ return BezTriple_getTriple( self );
+
+ /* look for default methods */
+ return Py_FindMethod( C_BezTriple_methods, ( PyObject * ) self, name );
+}
+
+/*****************************************************************************/
+/* Function: BezTripleSetAttr */
+/* Description: This is a callback function for the C_BezTriple type. It */
+/* sets BezTriple Data attributes (member variables). */
+/*****************************************************************************/
+static int BezTripleSetAttr( C_BezTriple * self, char *name, PyObject * value )
+{
+ PyObject *valtuple;
+ PyObject *error = NULL;
+
+ /* methods need a tuple object */
+
+ valtuple = Py_BuildValue( "(O)", value );
+ if( !valtuple )
+ return EXPP_ReturnIntError( PyExc_MemoryError,
+ "couldn't create PyTuple" );
+
+ /* process attributes */
+
+ if( strcmp( name, "pt" ) == 0 )
+ error = BezTriple_setPoints( self, valtuple );
+ else if( strcmp( name, "vec" ) == 0 )
+ error = BezTriple_setTriple( self, valtuple);
+ else { /* no match: signal attribute exception */
+ Py_DECREF( valtuple );
+ return EXPP_ReturnIntError
+ ( PyExc_KeyError, "attribute not found" );
}
- return l;
+
+ /* clean up */
+
+ Py_DECREF( valtuple );
+ if ( error != Py_None ) return -1;
+ Py_DECREF( Py_None );
+ return 0;
}
+/*****************************************************************************/
+/* Function: BezTripleRepr */
+/* Description: This is a callback function for the C_BezTriple type. It */
+/* builds a meaningful string to represent BezTriple objects. */
+/*****************************************************************************/
-/*
- * BezTriple_getTriple
- *
- * get the coordinate data for a BezTriple.
- * returns a list of 3 points.
- * list order is handle1, knot, handle2.
- * each point consists of a list of x,y,z float values.
+/*
+ * Meaning of fields in bezTriple
+ *
+ * handles h1, h2:
+ * 0=HD_FREE(black), 1=HD_AUTO(yellow), 2=HD_VECT(green), 3=HD_ALIGN(red)
+ * selected flags f1, f2, f3:
+ * 0 = false, 1 = true
+ * if f2 true, then f1 and and f3 also true
+ * hide:
+ * always seems to be 2 (IPO_BEZ)?
*/
-static PyObject *BezTriple_getTriple( C_BezTriple * self )
+static PyObject *BezTripleRepr( C_BezTriple * self )
{
- int i;
- struct BezTriple *bezt = self->beztriple;
- PyObject *retlist = PyList_New( 0 );
- PyObject *point;
+ char str[1000];
+ sprintf( str,
+ "[BezTriple [%f,%f,%f] [%f,%f,%f] [%f,%f,%f] [%d,%d] [%d,%d,%d]]\n",
+ self->beztriple->vec[0][0], self->beztriple->vec[0][1],
+ self->beztriple->vec[0][2], self->beztriple->vec[1][0],
+ self->beztriple->vec[1][1], self->beztriple->vec[1][2],
+ self->beztriple->vec[2][0], self->beztriple->vec[2][1],
+ self->beztriple->vec[2][2],
+#if 0
+ self->beztriple->alfa,
+ self->beztriple->s[0][0], self->beztriple->s[0][1],
+ self->beztriple->s[1][0], self->beztriple->s[1][1],
+ self->beztriple->s[2][0], self->beztriple->s[1][1],
+#endif
+ self->beztriple->h1, self->beztriple->h2,
+ self->beztriple->f1, self->beztriple->f2, self->beztriple->f3
+#if 0
+ , self->beztriple->hide
+#endif
+ );
+ return PyString_FromString( str );
+}
- for( i = 0; i < 3; i++ ) {
- point = Py_BuildValue( "[fff]",
- bezt->vec[i][0],
- bezt->vec[i][1], bezt->vec[i][2] );
- PyList_Append( retlist, point );
- }
+static struct BezTriple_handleType {
+ int type;
+ char *name;
+} handleNames[] = {
+ {HD_AUTO, "AUTO"},
+ {HD_ALIGN, "ALIGN"},
+ {HD_VECT, "VECTOR"},
+ {HD_FREE, "FREE"}
+};
- return retlist;
+/*****************************************************************************/
+/* Python C_BezTriple instance methods */
+/*****************************************************************************/
+
+/*
+ * Function: BezTriple_getPoints()
+ * Bpy: Blender.BezTriple.getPoints()
+ *
+ * return a list of x,y for knot point
+ *
+ * example:
+ * ipo = Blender.Ipo.New('Object','ObIpo')
+ * cu = ipo.getCurve('LocX')
+ * p = cu.getPoints()[0]
+ * [x,y] = p.getPoints()
+ */
+
+static PyObject *BezTriple_getPoints( C_BezTriple * self )
+{
+ struct BezTriple *bezt = self->beztriple;
+ PyObject *l = PyList_New( 0 );
+
+ PyList_Append( l, PyFloat_FromDouble( bezt->vec[1][0] ) );
+ PyList_Append( l, PyFloat_FromDouble( bezt->vec[1][1] ) );
+
+ return l;
}
+/*
+ * Function: BezTriple_setPoints()
+ * Bpy: Blender.BezTriple.setPoints([x,y])
+ *
+ * sets knot point to (x,y)
+ *
+ * example:
+ * ipo = Blender.Ipo.New('Object','ObIpo')
+ * cu = ipo.getCurve('LocX')
+ * p = cu.getPoints()[0]
+ * p.setPoints([1,2])
+ */
static PyObject *BezTriple_setPoints( C_BezTriple * self, PyObject * args )
{
-
int i;
struct BezTriple *bezt = self->beztriple;
PyObject *popo = 0;
- if( !PyArg_ParseTuple( args, "O", &popo ) )
- return ( EXPP_ReturnPyObjError
- ( PyExc_TypeError, "expected sequence argument" ) );
-
- if( PySequence_Check( popo ) == 0 ) {
- puts( "error in BezTriple_setPoints - expected sequence" );
- Py_INCREF( Py_None );
- return Py_None;
- }
+ /* only accept list of two numbers */
- {
- /*
- some debug stuff
- this will become an overloaded args check
- */
- int size = PySequence_Size( popo );
- printf( "\n dbg: sequence size is %d\n", size );
- }
+ if ( !PyArg_ParseTuple( args, "O", &popo ) ||
+ !PyList_Check( popo ) || PySequence_Size ( popo ) != 2 )
+ return EXPP_ReturnPyObjError ( PyExc_TypeError,
+ "expected list of two floats" );
+
+ if ( !PyNumber_Check ( PySequence_Fast_GET_ITEM( popo, 0 ) ) ||
+ !PyNumber_Check ( PySequence_Fast_GET_ITEM( popo, 0 ) ) )
+ return EXPP_ReturnPyObjError ( PyExc_TypeError,
+ "expected list of two floats" );
- for( i = 0; i < 2; i++ ) {
- PyObject *o = PySequence_GetItem( popo, i );
- if( !o )
- printf( "\n bad o. o no!\n" );
+ /* set x and y values of knot, then "futz" with handles */
- /* bezt->vec[1][i] = PyFloat_AsDouble (PyTuple_GetItem (popo, i)); */
- bezt->vec[1][i] = PyFloat_AsDouble( o );
+ for( i = 0; i < 2; i++ ) {
+ bezt->vec[1][i] = PyFloat_AsDouble(
+ PySequence_Fast_GET_ITEM( popo, i ) );
bezt->vec[0][i] = bezt->vec[1][i] - 1;
bezt->vec[2][i] = bezt->vec[1][i] + 1;
}
@@ -238,82 +356,167 @@
if( bezt->vec[2][0] < bezt->vec[1][0] )
bezt->vec[2][0] = bezt->vec[1][0];
- Py_INCREF( Py_None );
- return Py_None;
+ return EXPP_incr_ret( Py_None );
}
+/*
+ * Function: BezTriple_getTriple()
+ * Bpy: Blender.BezTriple.getTriple()
+ *
+ * get the coordinate data for a BezTriple.
+ * returns a list of 3 [x,y,z] points.
+ * list order is handle1, knot, handle2.
+ *
+ * example:
+ * ipo = Blender.Ipo.New('Object','ObIpo')
+ * cu = ipo.getCurve('LocX')
+ * p = cu.getPoints()[0]
+ * [h1,knot,h2] = p.getTriple()
+ */
-/*****************************************************************************/
-/* Function: BezTripleGetAttr */
-/* Description: This is a callback function for the C_BezTriple type. It */
-/* taccesses C_BezTriple "member variables" and methods. */
-/*****************************************************************************/
-static PyObject *BezTripleGetAttr( C_BezTriple * self, char *name )
+static PyObject *BezTriple_getTriple( C_BezTriple * self )
{
- if( strcmp( name, "pt" ) == 0 )
- return BezTriple_getPoints( self );
- else if( strcmp( name, "vec" ) == 0 )
- return BezTriple_getTriple( self );
+ int i;
+ struct BezTriple *bezt = self->beztriple;
+ PyObject *retlist = PyList_New( 0 );
+ PyObject *point;
- /* look for default methods */
- return Py_FindMethod( C_BezTriple_methods, ( PyObject * ) self, name );
+ for( i = 0; i < 3; i++ ) {
+ point = Py_BuildValue( "[fff]", bezt->vec[i][0],
+ bezt->vec[i][1], bezt->vec[i][2] );
+
+ PyList_Append( retlist, point );
+ }
+
+ return retlist;
}
-/*****************************************************************************/
-/* Function: BezTripleSetAttr */
-/* Description: This is a callback function for the C_BezTriple type. It */
-/* sets BezTriple Data attributes (member variables). */
-/*****************************************************************************/
-static int BezTripleSetAttr( C_BezTriple * self, char *name, PyObject * value )
+/*
+ * Function: BezTriple_setTriple()
+ * Bpy: Blender.BezTriple.setTriple([[f,f,f],[f,f,f],[f,f,f]])
+ *
+ * set the coordinate data for a BezTriple.
+ * input is a list of 3 [x,y,z] points.
+ * list order is handle1, knot, handle2.
+ *
+ * example:
+ * ipo = Blender.Ipo.New('Object','ObIpo')
+ * cu = ipo.getCurve('LocX')
+ * p = cu.getPoints()[0]
+ * [h1,knot,h2] = p.getTriple()
+ * p.setTriple([h1,knot,h2])
+ */
+
+static PyObject *BezTriple_setTriple( C_BezTriple * self, PyObject * args )
{
-#if 0
- /*
- this does not work at the moment: Wed Apr 7 2004
- when the necessary code to make pt act like a sequence is
- available, it will be reenabled
- */
+ int i, j;
+ struct BezTriple *bezt = self->beztriple;
+ PyObject *obj1, *obj2;
+ float f[3][3];
+ char * message = "expected three lists of three floats";
+
+ /* if input is not a list, or if list size not 3, error */
+
+ if ( !PyArg_ParseTuple( args, "O", &obj1 ) ||
+ !PyList_Check( obj1 ) || PySequence_Size ( obj1 ) != 3 )
+ return ( EXPP_ReturnPyObjError ( PyExc_TypeError, message ) );
+
+ /* check that argument contains 3 other lists */
+ /* check each list item to be sure it's a number */
+
+ for ( i = 0; i < 3; ++i ) {
+ obj2 = PySequence_Fast_GET_ITEM( obj1, i );
+ if ( !PyList_Check ( obj2 ) )
+ return ( EXPP_ReturnPyObjError ( PyExc_TypeError, message ) );
+ for ( j = 0; j < 3; ++j ) {
+ if ( !PyNumber_Check ( PySequence_Fast_GET_ITEM( obj2, j ) ) )
+ return ( EXPP_ReturnPyObjError ( PyExc_TypeError, message ) );
+ else
+ f[i][j] = PyFloat_AS_DOUBLE( ( PySequence_Fast_GET_ITEM( obj2, j ) ) );
+ }
+
+ }
- if( strcmp( name, "pt" ) == 0 )
- BezTriple_setPoints( self, value );
+ /* input is good, so copy to bezTriple and return */
- return 0; /* normal exit */
-#endif
+ for( i = 0; i < 3; i++ ) {
+ bezt->vec[i][0] = f[i][0];
+ bezt->vec[i][1] = f[i][1];
+ bezt->vec[i][2] = f[i][2];
+ }
+ return EXPP_incr_ret( Py_None );
+}
+
+/*
+ * Function: BezTriple_getHandle()
+ * Bpy: Blender.BezTriple.getHandle()
+ *
+ * get the handle types for BezTriple
+ * returns a tuple of 2 module constants, order is handle1, handle2.
+ *
+ * example:
+ * ipo = Blender.Ipo.New('Object','ObIpo')
+ * cu = ipo.getCurve('LocX')
+ * p = cu.getPoints()[0]
+ * (h1,h2) = p.getHandle()
+ */
+
+static PyObject *BezTriple_getHandle( C_BezTriple * self )
+{
+ unsigned int i;
+ struct BezTriple *bezt = self->beztriple;
+ PyObject * tuple = PyTuple_New(2);
+
+ //load tuple
+ for ( i = 0; i < sizeof(handleNames)/ sizeof (struct BezTriple_handleType); ++i ) {
+ if ( bezt->h1 == handleNames[i].type )
+ PyTuple_SET_ITEM( tuple, 0,
+ return_ModuleConstant(handleNames[i].name));
+ if ( bezt->h2 == handleNames[i].type )
+ PyTuple_SET_ITEM( tuple, 1,
+ return_ModuleConstant(handleNames[i].name));
+ }
- return ( EXPP_ReturnIntError( PyExc_AttributeError,
- "cannot set a read-only attribute" ) );
+ return tuple;
}
-/*****************************************************************************/
-/* Function: BezTripleRepr */
-/* Description: This is a callback function for the C_BezTriple type. It */
-/* builds a meaninful string to represent BezTriple objects. */
-/*****************************************************************************/
-static PyObject *BezTripleRepr( C_BezTriple * self )
+/*
+ * Function: BezTriple_setHandle()
+ * Bpy: Blender.BezTriple.setHandle([c,c])
+ *
+ * set the handle types for BezTriple
+ * takes a list of 2 module constants, order is handle1, handle2.
+ *
+ * example:
+ * ipo = Blender.Ipo.New('Object','ObIpo')
+ * cu = ipo.getCurve('LocX')
+ * p = cu.getPoints()[0]
+ * p.setHandle((Blender.BezTriple.AUTO,Blender.BezTriple.AUTO])
+ */
+
+static PyObject *BezTriple_setHandle( C_BezTriple * self, PyObject *args)
{
- /* float vec[3][3];
- float alfa;
- short s[3][2];
- short h1, h2;
- char f1, f2, f3, hide;
- */
- char str[1000];
- sprintf( str,
- "BezTriple %f %f %f %f %f %f %f %f %f %f\n %d %d %d %d %d %d %d %d %d %d %d %d\n",
- self->beztriple->vec[0][0], self->beztriple->vec[0][1],
- self->beztriple->vec[0][2], self->beztriple->vec[1][0],
- self->beztriple->vec[1][1], self->beztriple->vec[1][2],
- self->beztriple->vec[2][0], self->beztriple->vec[2][1],
- self->beztriple->vec[2][2], self->beztriple->alfa,
- self->beztriple->s[0][0], self->beztriple->s[0][1],
- self->beztriple->s[1][0], self->beztriple->s[1][1],
- self->beztriple->s[2][0], self->beztriple->s[1][1],
- self->beztriple->h1, self->beztriple->h2, self->beztriple->f1,
- self->beztriple->f2, self->beztriple->f3,
- self->beztriple->hide );
- return PyString_FromString( str );
+ BPy_constant *const1, *const2;
+ struct BezTriple *bezt = self->beztriple;
+
+ /* only accept a list of two module constants */
+
+ if ( PySequence_Size ( args ) != 1 ||
+ !PyTuple_Check( PySequence_Fast_GET_ITEM( args, 0 ) ) ||
+ !PyArg_ParseTuple( args, "(O!O!)", &constant_Type, &const1,
+ &constant_Type, &const2 ) )
+ return ( EXPP_ReturnPyObjError
+ ( PyExc_TypeError, "expected tuple of two module constants" ) );
+
+ /* assign the handle */
+
+ bezt->h1 = PyInt_AS_LONG(PyDict_GetItemString(const1->dict, "value"));
+ bezt->h2 = PyInt_AS_LONG(PyDict_GetItemString(const2->dict, "value"));
+
+ return EXPP_incr_ret( Py_None );
}
-/* Three Python BezTriple_Type helper functions needed by the Object module: */
+/* Three Python BezTriple_Type helper functions needed by the Object module */
/*****************************************************************************/
/* Function: BezTriple_CreatePyObject */
@@ -347,11 +550,72 @@
}
/*****************************************************************************/
-/* Function: BezTriple_FromPyObject */
+/* Function: BezTriple_FromPyObject */
/* Description: This function returns the Blender beztriple from the given */
/* PyObject. */
/*****************************************************************************/
BezTriple *BezTriple_FromPyObject( PyObject * pyobj )
{
return ( ( C_BezTriple * ) pyobj )->beztriple;
+}
+
+/*****************************************************************************/
+/* Function: BezTriple_Init */
+/*****************************************************************************/
+
+PyObject *BezTriple_Init( void )
+{
+ PyObject *submodule;
+
+ submodule = Py_InitModule3( "Blender.BezTriple", M_BezTriple_methods,
+ NULL );
+ PyModule_AddObject( submodule, "AUTO",
+ generate_ModuleIntConstant("BezTriple.AUTO", HD_AUTO, NULL));
+ PyModule_AddObject( submodule, "FREE",
+ generate_ModuleIntConstant("BezTriple.FREE", HD_FREE, NULL));
+ PyModule_AddObject( submodule, "ALIGN",
+ generate_ModuleIntConstant("BezTriple.ALIGN", HD_ALIGN, NULL));
+ PyModule_AddObject( submodule, "VECTOR",
+ generate_ModuleIntConstant("BezTriple.VECTOR", HD_VECT, NULL));
+
+ return ( submodule );
+}
+
+/*
+ * helpers to create and read module constant; this could be put into
+ * gen_utils.c or constant.c
+ */
+
+static PyObject *generate_ModuleIntConstant(char *name, int value, char *doc)
+{
+ PyObject *constant = M_constant_New();
+
+ constant_insert((BPy_constant*)constant, "value", PyInt_FromLong(value));
+ constant_insert((BPy_constant*)constant, "name", PyString_FromString(name));
+#if 0
+ constant_insert((BPy_constant*)constant, "__doc__", PyString_FromString(doc));
+#endif
+
+ Py_INCREF(constant);
+ return constant;
+}
+
+static PyObject *return_ModuleConstant( char *constant_name){
+
+ PyObject *module = NULL, *dict = NULL, *constant = NULL;;
+
+ module = PyImport_AddModule("Blender.BezTriple");
+ if(!module){ //null = error returning module
+ return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
+ "error encountered with returning module constant..." ) );
+ }
+ dict = PyModule_GetDict(module); //never fails
+
+ constant = PyDict_GetItemString(dict, constant_name);
+ if(!constant){ //null = key not found
+ return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
+ "error encountered with returning module constant..." ) );
+ }
+
+ return EXPP_incr_ret( constant );
}
Index: blender/source/blender/python/api2_2x/Blender.c
===================================================================
RCS file: /cvsroot/bf-blender/blender/source/blender/python/api2_2x/Blender.c,v
retrieving revision 1.60
diff -u -u -r1.60 Blender.c
--- blender/source/blender/python/api2_2x/Blender.c 20 May 2005 20:52:47 -0000 1.60
+++ blender/source/blender/python/api2_2x/Blender.c 1 Jun 2005 05:51:32 -0000
@@ -788,6 +788,7 @@
PyDict_SetItemString( dict, "Armature", Armature_Init( ) );
PyDict_SetItemString( dict, "Ipo", Ipo_Init( ) );
PyDict_SetItemString( dict, "IpoCurve", IpoCurve_Init( ) );
+ PyDict_SetItemString( dict, "BezTriple", BezTriple_Init( ) );
PyDict_SetItemString( dict, "Metaball", Metaball_Init( ) );
PyDict_SetItemString( dict, "Image", Image_Init( ) );
PyDict_SetItemString( dict, "Window", Window_Init( ) );

File Metadata

Mime Type
text/x-diff
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
72/8a/be5c42c90cd399f7cccbb284a976

Event Timeline