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

Patch from Martin Poirier.

Browse Source 
Misc bpy Curve fixes and updates, includes bugs #1687 and #2637
This commit is contained in:
Stephen Swaney
2005-06-13 19:15:02 +00:00
parent de567cd0cc
commit 769fa6252d
10 changed files with 717 additions and 227 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/include/BDR_editcurve.h
View File

@@ -66,6 +66,8 @@ short findnearestNurbvert(short sel, struct Nurb **nurb,
struct BezTriple **bezt, struct BPoint **bp); struct BezTriple **bezt, struct BPoint **bp);
void findselectedNurbvert(struct Nurb **nu, struct BezTriple **bezt, void findselectedNurbvert(struct Nurb **nu, struct BezTriple **bezt,
struct BPoint **bp); struct BPoint **bp);
int convertspline(short type, struct Nurb *nu);
void setsplinetype(short type); void setsplinetype(short type);
void rotate_direction_nurb(struct Nurb *nu); void rotate_direction_nurb(struct Nurb *nu);
int is_u_selected(struct Nurb *nu, int u); int is_u_selected(struct Nurb *nu, int u);

318
source/blender/python/api2_2x/BezTriple.c
View File

@@ -24,7 +24,8 @@
* *
* This is a new part of Blender. * This is a new part of Blender.
* *
* Contributor(s): Jacques Guignot * Contributor(s): Jacques Guignot RIP 2005,
* Stephen Swaney
* *
* ***** END GPL/BL DUAL LICENSE BLOCK ***** * ***** END GPL/BL DUAL LICENSE BLOCK *****
*/ */
@@ -39,48 +40,57 @@
#include <BKE_library.h> #include <BKE_library.h>
#include <BLI_blenlib.h> #include <BLI_blenlib.h>
#include <DNA_ipo_types.h> #include <DNA_ipo_types.h>
#include <MEM_guardedalloc.h>
#include "constant.h" #include "constant.h"
#include "gen_utils.h" #include "gen_utils.h"
/*****************************************************************************/ /***************************************************************************
/* Python API function prototypes for the BezTriple module. */ Python API function prototypes for the BezTriple module.
/*****************************************************************************/ ***************************************************************************/
static PyObject *M_BezTriple_New( PyObject * self, PyObject * args ); static PyObject *M_BezTriple_New( PyObject * self, PyObject * args );
static PyObject *M_BezTriple_Get( PyObject * self, PyObject * args ); static PyObject *M_BezTriple_Get( PyObject * self, PyObject * args );
/*****************************************************************************/ /*************************************
/* Python C_BezTriple instance methods declarations: */ Doc strings for the BezTriple module
/*****************************************************************************/ *************************************/
static PyObject *BezTriple_setPoints( C_BezTriple * self, PyObject * args );
static PyObject *BezTriple_getPoints( C_BezTriple * self );
static PyObject *BezTriple_getTriple( C_BezTriple * self );
/*****************************************************************************/ static char M_BezTriple_doc[] = "The Blender BezTriple module\n";
/* Python BezTriple_Type callback function prototypes: */
/*****************************************************************************/
static void BezTripleDeAlloc( C_BezTriple * self );
static int BezTripleSetAttr( C_BezTriple * self, char *name, PyObject * v );
static PyObject *BezTripleGetAttr( C_BezTriple * self, char *name );
static PyObject *BezTripleRepr( C_BezTriple * self );
/*****************************************************************************/ /****************************************************************************
/* Python method structure definition for Blender.BezTriple module: */ Python BPy_BezTriple instance methods declarations:
/*****************************************************************************/ ****************************************************************************/
static PyObject *BezTriple_setPoints( BPy_BezTriple * self, PyObject * args );
static PyObject *BezTriple_getPoints( BPy_BezTriple * self );
static PyObject *BezTriple_getTriple( BPy_BezTriple * self );
/****************************************************************************
Python BezTriple_Type callback function prototypes:
*****************************************************************************/
static void BezTripleDeAlloc( BPy_BezTriple * self );
static int BezTripleSetAttr( BPy_BezTriple * self, char *name, PyObject * v );
static PyObject *BezTripleGetAttr( BPy_BezTriple * self, char *name );
static PyObject *BezTripleRepr( BPy_BezTriple * self );
static PyObject *BezTriple_Str( BPy_BezTriple * self );
/****************************************************************************
Python method structure definition for Blender.BezTriple module:
****************************************************************************/
struct PyMethodDef M_BezTriple_methods[] = { struct PyMethodDef M_BezTriple_methods[] = {
{"New", ( PyCFunction ) M_BezTriple_New, METH_VARARGS | METH_KEYWORDS, {"New", ( PyCFunction ) M_BezTriple_New, METH_VARARGS | METH_KEYWORDS,
0}, 0},
/* {"New", ( PyCFunction ) M_BezTriple_New, METH_O, 0}, */
{"Get", M_BezTriple_Get, METH_VARARGS, 0}, {"Get", M_BezTriple_Get, METH_VARARGS, 0},
{"get", M_BezTriple_Get, METH_VARARGS, 0}, {"get", M_BezTriple_Get, METH_VARARGS, 0},
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };
/*****************************************************************************/ /*****************************************************************************/
/* Python C_BezTriple methods table: */ /* Python BPy_BezTriple methods table: */
/*****************************************************************************/ /*****************************************************************************/
static PyMethodDef C_BezTriple_methods[] = { static PyMethodDef BPy_BezTriple_methods[] = {
/* name, method, flags, doc */ /* name, method, flags, doc */
{"setPoints", ( PyCFunction ) BezTriple_setPoints, METH_VARARGS, {"setPoints", ( PyCFunction ) BezTriple_setPoints, METH_VARARGS,
"(str) - Change BezTriple point coordinates"}, "(str) - Change BezTriple point coordinates"},
@@ -96,10 +106,10 @@ static PyMethodDef C_BezTriple_methods[] = {
/* Python BezTriple_Type structure definition: */ /* Python BezTriple_Type structure definition: */
/*****************************************************************************/ /*****************************************************************************/
PyTypeObject BezTriple_Type = { PyTypeObject BezTriple_Type = {
PyObject_HEAD_INIT( NULL ) /* required python macro */ PyObject_HEAD_INIT( NULL ) /* required python macro */
0, /* ob_size */ 0, /* ob_size */
"BezTriple", /* tp_name */ "BezTriple", /* tp_name */
sizeof( C_BezTriple ), /* tp_basicsize */ sizeof( BPy_BezTriple ), /* tp_basicsize */
0, /* tp_itemsize */ 0, /* tp_itemsize */
/* methods */ /* methods */
( destructor ) BezTripleDeAlloc, /* tp_dealloc */ ( destructor ) BezTripleDeAlloc, /* tp_dealloc */
@@ -112,49 +122,71 @@ PyTypeObject BezTriple_Type = {
0, /* tp_as_sequence */ 0, /* tp_as_sequence */
0, /* tp_as_mapping */ 0, /* tp_as_mapping */
0, /* tp_as_hash */ 0, /* tp_as_hash */
0, 0, 0, 0, 0, 0, 0, /* tp_call */
0, /* ( reprfunc) BezTriple_Str, tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
0, /* tp_flags */
0, /* tp_doc */ 0, /* tp_doc */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
C_BezTriple_methods, /* tp_methods */ BPy_BezTriple_methods, /* tp_methods */
0, /* tp_members */ 0, /* tp_members */
0, /* tm_getset */ 0, /* tm_getset */
0 0
}; };
/*****************************************************************************/ /****************************************************************************
/* Function: M_BezTriple_New */ Function: M_BezTriple_New
/* Python equivalent: Blender.BezTriple.New */ Python equivalent: Blender.BezTriple.New
/*****************************************************************************/ ****************************************************************************/
static PyObject *M_BezTriple_New( PyObject * self, PyObject * args )
static PyObject *M_BezTriple_New( PyObject* self, PyObject * args )
{ {
return 0; PyObject* in_args = NULL;
if( !PyArg_ParseTuple( args, "|O", &in_args) ) {
return( EXPP_ReturnPyObjError
( PyExc_AttributeError,
"expected sequence of 3 or 9 floats or nothing"));
}
if( !in_args ) {
in_args = Py_BuildValue( "(fff)", 0.0, 0.0, 0.0 );
}
return newBezTriple( in_args );
} }
/*****************************************************************************/ /****************************************************************************
/* Function: M_BezTriple_Get */ Function: M_BezTriple_Get
/* Python equivalent: Blender.BezTriple.Get */ Python equivalent: Blender.BezTriple.Get
/* Description: Receives a string and returns the ipo data obj */ Description: Receives a string and returns the ipo data obj
/* whose name matches the string. If no argument is */ whose name matches the string. If no argument is
/* passed in, a list of all ipo data names in the */ passed in, a list of all ipo data names in the
/* current scene is returned. */ current scene is returned.
/*****************************************************************************/ ****************************************************************************/
static PyObject *M_BezTriple_Get( PyObject * self, PyObject * args ) static PyObject *M_BezTriple_Get( PyObject * self, PyObject * args )
{ {
return 0; return 0;
} }
/*****************************************************************************/ /****************************************************************************
/* Function: BezTripleDeAlloc */ Function: BezTripleDeAlloc
/* Description: This is a callback function for the C_BezTriple type. It is */ Description: This is a callback function for the BPy_BezTriple type. It is
/* the destructor function. */ the destructor function.
/*****************************************************************************/ ****************************************************************************/
static void BezTripleDeAlloc( C_BezTriple * self ) static void BezTripleDeAlloc( BPy_BezTriple * self )
{ {
if( self->own_memory)
MEM_freeN( self->beztriple );
PyObject_DEL( self ); PyObject_DEL( self );
} }
static PyObject *BezTriple_getPoints( C_BezTriple * self ) static PyObject *BezTriple_getPoints( BPy_BezTriple * self )
{ {
struct BezTriple *bezt = self->beztriple; struct BezTriple *bezt = self->beztriple;
PyObject *l = PyList_New( 0 ); PyObject *l = PyList_New( 0 );
@@ -175,7 +207,7 @@ static PyObject *BezTriple_getPoints( C_BezTriple * self )
* each point consists of a list of x,y,z float values. * each point consists of a list of x,y,z float values.
*/ */
static PyObject *BezTriple_getTriple( C_BezTriple * self ) static PyObject *BezTriple_getTriple( BPy_BezTriple * self )
{ {
int i; int i;
struct BezTriple *bezt = self->beztriple; struct BezTriple *bezt = self->beztriple;
@@ -194,7 +226,7 @@ static PyObject *BezTriple_getTriple( C_BezTriple * self )
} }
static PyObject *BezTriple_setPoints( C_BezTriple * self, PyObject * args ) static PyObject *BezTriple_setPoints( BPy_BezTriple * self, PyObject * args )
{ {
int i; int i;
@@ -245,26 +277,30 @@ static PyObject *BezTriple_setPoints( C_BezTriple * self, PyObject * args )
/*****************************************************************************/ /*****************************************************************************/
/* Function: BezTripleGetAttr */ /* Function: BezTripleGetAttr */
/* Description: This is a callback function for the C_BezTriple type. It */ /* Description: This is a callback function for the BPy_BezTriple type. It */
/* taccesses C_BezTriple "member variables" and methods. */ /* taccesses BPy_BezTriple "member variables" and methods. */
/*****************************************************************************/ /*****************************************************************************/
static PyObject *BezTripleGetAttr( C_BezTriple * self, char *name ) static PyObject *BezTripleGetAttr( BPy_BezTriple * self, char *name )
{ {
if( strcmp( name, "pt" ) == 0 ) if( strcmp( name, "pt" ) == 0 )
return BezTriple_getPoints( self ); return BezTriple_getPoints( self );
else if( strcmp( name, "vec" ) == 0 ) else if( strcmp( name, "vec" ) == 0 )
return BezTriple_getTriple( self ); return BezTriple_getTriple( self );
else if( strcmp( name, "tilt" ) == 0 )
return PyFloat_FromDouble(self->beztriple->alfa);
else if( strcmp( name, "__members__" ) == 0 )
return Py_BuildValue( "[s,s,s]", "pt", "vec", "tilt" );
/* look for default methods */ /* look for default methods */
return Py_FindMethod( C_BezTriple_methods, ( PyObject * ) self, name ); return Py_FindMethod( BPy_BezTriple_methods, ( PyObject * ) self, name );
} }
/*****************************************************************************/ /*****************************************************************************/
/* Function: BezTripleSetAttr */ /* Function: BezTripleSetAttr */
/* Description: This is a callback function for the C_BezTriple type. It */ /* Description: This is a callback function for the BPy_BezTriple type. It */
/* sets BezTriple Data attributes (member variables). */ /* sets BezTriple Data attributes (member variables). */
/*****************************************************************************/ /*****************************************************************************/
static int BezTripleSetAttr( C_BezTriple * self, char *name, PyObject * value ) static int BezTripleSetAttr( BPy_BezTriple * self, char *name, PyObject * value )
{ {
#if 0 #if 0
/* /*
@@ -278,6 +314,13 @@ static int BezTripleSetAttr( C_BezTriple * self, char *name, PyObject * value )
return 0; /* normal exit */ return 0; /* normal exit */
#endif #endif
if( strcmp( name, "tilt" ) == 0 ) {
if (!PyFloat_Check( value ) )
return EXPP_ReturnIntError( PyExc_TypeError, "expected a float" );
self->beztriple->alfa = (float)PyFloat_AsDouble( value );
return 0;
}
return ( EXPP_ReturnIntError( PyExc_AttributeError, return ( EXPP_ReturnIntError( PyExc_AttributeError,
"cannot set a read-only attribute" ) ); "cannot set a read-only attribute" ) );
@@ -285,10 +328,10 @@ static int BezTripleSetAttr( C_BezTriple * self, char *name, PyObject * value )
/*****************************************************************************/ /*****************************************************************************/
/* Function: BezTripleRepr */ /* Function: BezTripleRepr */
/* Description: This is a callback function for the C_BezTriple type. It */ /* Description: This is a callback function for the BPy_BezTriple type. It */
/* builds a meaninful string to represent BezTriple objects. */ /* builds a meaninful string to represent BezTriple objects. */
/*****************************************************************************/ /*****************************************************************************/
static PyObject *BezTripleRepr( C_BezTriple * self ) static PyObject *BezTripleRepr( BPy_BezTriple * self )
{ {
/* float vec[3][3]; /* float vec[3][3];
float alfa; float alfa;
@@ -313,29 +356,75 @@ static PyObject *BezTripleRepr( C_BezTriple * self )
return PyString_FromString( str ); return PyString_FromString( str );
} }
/*
BezTriple_Str
display object as string.
equivalent to python str(o)
*/
static PyObject *BezTriple_Str( BPy_BezTriple * self )
{
BezTriple *p = self->beztriple;
/* fixme: */
return PyString_FromFormat(
"BezTriple (%f %f %f) (%f %f %f) (%f %f %f) alpha %f\n (%d %d) (%d %d) (%d %d) h1:%d h2:%d f1:%d f2:%d f3:%d hide:%d",
p->vec[0][0], p->vec[0][1], p->vec[0][2],
p->vec[1][0], p->vec[1][1], p->vec[1][2],
p->vec[2][0], p->vec[2][1], p->vec[2][2],
p->alfa,
p->s[0][0], p->s[0][1],
p->s[1][0], p->s[1][1],
p->s[2][0], p->s[1][1],
p->h1, p->h2, p->f1,
p->f2, p->f3,
p->hide );
}
/*
BezTriple_Init
*/
PyObject *BezTriple_Init( void )
{
PyObject *submodule;
BezTriple_Type.ob_type = &PyType_Type;
submodule = Py_InitModule3( "Blender.BezTriple",
M_BezTriple_methods,
M_BezTriple_doc );
return submodule;
}
/* 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 */ Function: BezTriple_CreatePyObject
/* Description: This function will create a new C_BezTriple from an existing */ Description: This function will create a new BPy_BezTriple from an existing
/* Blender ipo structure. */ Blender ipo structure.
/*****************************************************************************/ ****************************************************************************/
PyObject *BezTriple_CreatePyObject( BezTriple * bzt ) PyObject *BezTriple_CreatePyObject( BezTriple * bzt )
{ {
C_BezTriple *pybeztriple; BPy_BezTriple *pybeztriple;
pybeztriple = pybeztriple =
( C_BezTriple * ) PyObject_NEW( C_BezTriple, &BezTriple_Type ); ( BPy_BezTriple * ) PyObject_NEW( BPy_BezTriple, &BezTriple_Type );
if( !pybeztriple ) if( !pybeztriple )
return EXPP_ReturnPyObjError( PyExc_MemoryError, return EXPP_ReturnPyObjError( PyExc_MemoryError,
"couldn't create C_BezTriple object" ); "couldn't create BPy_BezTriple object" );
pybeztriple->beztriple = bzt; pybeztriple->beztriple = bzt;
return ( PyObject * ) pybeztriple; return ( PyObject * ) pybeztriple;
} }
/*****************************************************************************/ /*****************************************************************************/
/* Function: BezTriple_CheckPyObject */ /* Function: BezTriple_CheckPyObject */
/* Description: This function returns true when the given PyObject is of the */ /* Description: This function returns true when the given PyObject is of the */
@@ -353,5 +442,100 @@ int BezTriple_CheckPyObject( PyObject * pyobj )
/*****************************************************************************/ /*****************************************************************************/
BezTriple *BezTriple_FromPyObject( PyObject * pyobj ) BezTriple *BezTriple_FromPyObject( PyObject * pyobj )
{ {
return ( ( C_BezTriple * ) pyobj )->beztriple; return ( ( BPy_BezTriple * ) pyobj )->beztriple;
}
/*
Create a new BezTriple
input args is a sequence - either 3 or 9 floats
*/
PyObject *newBezTriple( PyObject *args)
{
BPy_BezTriple *pybez = NULL;
int length;
float numbuf[9];
/*
check input args:
sequence of nine floats - x,y,z for h1, pt, h2
sequence of 3 floats - x,y,z for pt with zero len handles in AUTO mode
*/
/* do we have a sequence of the right length? */
if( ! PySequence_Check( args )) {
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected better stuff"));
}
length = PySequence_Length( args );
if( length != 9 && length != 3 )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"wrong number of points");
{
int i;
PyObject *pyo;
for( i = 0; i < length; i++) {
pyo = PySequence_GetItem( args, i );
if( !pyo )
return EXPP_ReturnPyObjError
( PyExc_AttributeError,
"wrong number of points");
if( !PyFloat_Check( pyo ))
return EXPP_ReturnPyObjError
( PyExc_AttributeError,
"sequence item not number");
numbuf[i] = (float) PyFloat_AsDouble( pyo );
Py_DECREF( pyo ); /* from GetItem() */
}
}
/* create our bpy object */
pybez = ( BPy_BezTriple* ) PyObject_New( BPy_BezTriple,
&BezTriple_Type );
if( ! pybez )
return EXPP_ReturnPyObjError( PyExc_MemoryError,
"PyObject_New failed");
pybez->beztriple = MEM_callocN( sizeof( BezTriple ), "new bpytriple");
/* check malloc */
pybez->own_memory = 1; /* we own it. must free later */
switch( length ) {
case 9: {
int i,j;
int num = 0;
for( i = 0; i < 3; i++ ){
for( j = 0; j < 3; j++){
pybez->beztriple->vec[i][j] = numbuf[num ++];
}
}
}
break;
case 3: {
int i;
int num = 0;
/* set h1, pt, and h2 to the same values. */
for( i = 0; i < 3; i++ ) {
pybez->beztriple->vec[0][i] = numbuf[num];
pybez->beztriple->vec[1][i] = numbuf[num];
pybez->beztriple->vec[2][i] = numbuf[num];
++num;
}
}
break;
default:
/* we should not be here! */
break;
}
pybez->beztriple->h1 = HD_AUTO;
pybez->beztriple->h2 = HD_AUTO;
return ( PyObject* ) pybez;
} }

19
source/blender/python/api2_2x/BezTriple.h
View File

@@ -25,7 +25,7 @@
* *
* This is a new part of Blender. * This is a new part of Blender.
* *
* Contributor(s): Jacques Guignot * Contributor(s): Jacques Guignot, Stephen Swaney
* *
* ***** END GPL/BL DUAL LICENSE BLOCK ***** * ***** END GPL/BL DUAL LICENSE BLOCK *****
*/ */
@@ -36,14 +36,21 @@
#include <Python.h> #include <Python.h>
#include <DNA_curve_types.h> #include <DNA_curve_types.h>
/*****************************************************************************/ extern PyTypeObject BezTriple_Type;
/* Python C_BezTriple structure definition: */
/*****************************************************************************/ /* type check macro */
#define BPy_BezTriple_Check(o) \
( (o)->ob_type == &BezTriple_Type)
/****************************************************************************
Python BPy_BezTriple structure definition:
****************************************************************************/
typedef struct { typedef struct {
PyObject_HEAD /* required python macro */ PyObject_HEAD /* required python macro */
BezTriple * beztriple; BezTriple * beztriple;
} C_BezTriple; int own_memory; /* true == we own this memory and must delete. */
} BPy_BezTriple;
/* /*
* prototypes * prototypes
@@ -52,5 +59,7 @@ typedef struct {
PyObject *BezTriple_CreatePyObject( BezTriple * bzt ); PyObject *BezTriple_CreatePyObject( BezTriple * bzt );
int BezTriple_CheckPyObject( PyObject * pyobj ); int BezTriple_CheckPyObject( PyObject * pyobj );
BezTriple *BezTriple_FromPyObject( PyObject * pyobj ); BezTriple *BezTriple_FromPyObject( PyObject * pyobj );
PyObject *newBezTriple( PyObject *args );
PyObject *BezTriple_Init( void );
#endif /* EXPP_BEZTRIPLE_H */ #endif /* EXPP_BEZTRIPLE_H */

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

@@ -803,8 +803,8 @@ void M_Blender_Init( void )
PyDict_SetItemString( dict, "Mathutils", Mathutils_Init( ) ); PyDict_SetItemString( dict, "Mathutils", Mathutils_Init( ) );
PyDict_SetItemString( dict, "Library", Library_Init( ) ); PyDict_SetItemString( dict, "Library", Library_Init( ) );
PyDict_SetItemString( dict, "Sound", Sound_Init( ) ); PyDict_SetItemString( dict, "Sound", Sound_Init( ) );
PyDict_SetItemString( dict, "CurNurb", CurNurb_Init( ) ); PyDict_SetItemString( dict, "CurNurb", CurNurb_Init( ) );
PyDict_SetItemString( dict, "BezTriple", BezTriple_Init( ) );
PyModule_AddIntConstant( module, "TRUE", 1 ); PyModule_AddIntConstant( module, "TRUE", 1 );
PyModule_AddIntConstant( module, "FALSE", 0 ); PyModule_AddIntConstant( module, "FALSE", 0 );

275
source/blender/python/api2_2x/CurNurb.c
View File

@@ -32,6 +32,7 @@
#include "Python.h" #include "Python.h"
#include "DNA_curve_types.h" #include "DNA_curve_types.h"
#include "BKE_curve.h" #include "BKE_curve.h"
#include "BDR_editcurve.h" /* for convertspline */
#include "MEM_guardedalloc.h" #include "MEM_guardedalloc.h"
#include "gen_utils.h" #include "gen_utils.h"
@@ -52,8 +53,11 @@ static PyObject *CurNurb_getFlagU( BPy_CurNurb * self );
static PyObject *CurNurb_setFlagU( BPy_CurNurb * self, PyObject * args ); static PyObject *CurNurb_setFlagU( BPy_CurNurb * self, PyObject * args );
static PyObject *CurNurb_getFlagV( BPy_CurNurb * self ); static PyObject *CurNurb_getFlagV( BPy_CurNurb * self );
static PyObject *CurNurb_setFlagV( BPy_CurNurb * self, PyObject * args ); static PyObject *CurNurb_setFlagV( BPy_CurNurb * self, PyObject * args );
static PyObject *CurNurb_getType( BPy_CurNurb * self );
static PyObject *CurNurb_setType( BPy_CurNurb * self, PyObject * args );
/* static PyObject* CurNurb_setXXX( BPy_CurNurb* self, PyObject* args ); */ /* static PyObject* CurNurb_setXXX( BPy_CurNurb* self, PyObject* args ); */
PyObject *CurNurb_getPoint( BPy_CurNurb * self, int index ); PyObject *CurNurb_getPoint( BPy_CurNurb * self, int index );
static int CurNurb_setPoint( BPy_CurNurb * self, int index, PyObject * ob );
static int CurNurb_length( PyInstanceObject * inst ); static int CurNurb_length( PyInstanceObject * inst );
static PyObject *CurNurb_getIter( BPy_CurNurb * self ); static PyObject *CurNurb_getIter( BPy_CurNurb * self );
static PyObject *CurNurb_iterNext( BPy_CurNurb * self ); static PyObject *CurNurb_iterNext( BPy_CurNurb * self );
@@ -61,6 +65,7 @@ PyObject *CurNurb_append( BPy_CurNurb * self, PyObject * args );
PyObject *CurNurb_pointAtIndex( Nurb * nurb, int index ); PyObject *CurNurb_pointAtIndex( Nurb * nurb, int index );
static PyObject *CurNurb_isNurb( BPy_CurNurb * self ); static PyObject *CurNurb_isNurb( BPy_CurNurb * self );
static PyObject *CurNurb_isCyclic( BPy_CurNurb * self ); static PyObject *CurNurb_isCyclic( BPy_CurNurb * self );
static PyObject *CurNurb_dump( BPy_CurNurb * self );
char M_CurNurb_doc[] = "CurNurb"; char M_CurNurb_doc[] = "CurNurb";
@@ -117,16 +122,21 @@ static PyMethodDef BPy_CurNurb_methods[] = {
"( index ) - set flagV and recalculate the knots (0: uniform, 1: endpoints, 2: bezier)"}, "( index ) - set flagV and recalculate the knots (0: uniform, 1: endpoints, 2: bezier)"},
{"getFlagV", ( PyCFunction ) CurNurb_getFlagV, METH_NOARGS, {"getFlagV", ( PyCFunction ) CurNurb_getFlagV, METH_NOARGS,
"( ) - get flagV of the knots"}, "( ) - get flagV of the knots"},
{"setType", ( PyCFunction ) CurNurb_setType, METH_VARARGS,
"( type ) - change the type of the curve (Poly: 0, Bezier: 1, NURBS: 4)"},
{"getType", ( PyCFunction ) CurNurb_getType, METH_NOARGS,
"( ) - get the type of the curve (Poly: 0, Bezier: 1, NURBS: 4)"},
{"append", ( PyCFunction ) CurNurb_append, METH_VARARGS, {"append", ( PyCFunction ) CurNurb_append, METH_VARARGS,
"( point ) - add a new point. arg is BezTriple or list of x,y,z,w floats"}, "( point ) - add a new point. arg is BezTriple or list of x,y,z,w floats"},
{"isNurb", ( PyCFunction ) CurNurb_isNurb, METH_NOARGS, {"isNurb", ( PyCFunction ) CurNurb_isNurb, METH_NOARGS,
"( ) - boolean function tests if this spline is type nurb or bezier"}, "( ) - boolean function tests if this spline is type nurb or bezier"},
{"isCyclic", ( PyCFunction ) CurNurb_isCyclic, METH_NOARGS, {"isCyclic", ( PyCFunction ) CurNurb_isCyclic, METH_NOARGS,
"( ) - boolean function tests if this spline is cyclic (closed) or not (open)"}, "( ) - boolean function tests if this spline is cyclic (closed) or not (open)"},
{"dump", ( PyCFunction ) CurNurb_dump, METH_NOARGS,
"( ) - dumps Nurb data)"},
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };
/* /*
* methods for CurNurb as sequece * methods for CurNurb as sequece
*/ */
@@ -137,7 +147,7 @@ static PySequenceMethods CurNurb_as_sequence = {
( intargfunc ) 0, /* sq_repeat */ ( intargfunc ) 0, /* sq_repeat */
( intargfunc ) CurNurb_getPoint, /* sq_item */ ( intargfunc ) CurNurb_getPoint, /* sq_item */
( intintargfunc ) 0, /* sq_slice */ ( intintargfunc ) 0, /* sq_slice */
0, /* sq_ass_item */ ( intobjargproc ) CurNurb_setPoint, /* sq_ass_item */
0, /* sq_ass_slice */ 0, /* sq_ass_slice */
( objobjproc ) 0, /* sq_contains */ ( objobjproc ) 0, /* sq_contains */
0, 0,
@@ -261,6 +271,12 @@ static PyObject *CurNurb_getAttr( BPy_CurNurb * self, char *name )
else if( strcmp( name, "flagV" ) == 0 ) else if( strcmp( name, "flagV" ) == 0 )
attr = CurNurb_getFlagV( self ); attr = CurNurb_getFlagV( self );
else if( strcmp( name, "type" ) == 0 )
attr = CurNurb_getType( self );
else if( strcmp( name, "__members__" ) == 0 )
attr = Py_BuildValue( "[s,s,s,s,s]", "mat_index", "points", "flagU", "flagV", "type" );
if( !attr ) if( !attr )
return EXPP_ReturnPyObjError( PyExc_MemoryError, return EXPP_ReturnPyObjError( PyExc_MemoryError,
"couldn't create PyObject" ); "couldn't create PyObject" );
@@ -292,11 +308,16 @@ static int CurNurb_setAttr( BPy_CurNurb * self, char *name, PyObject * value )
if( strcmp( name, "mat_index" ) == 0 ) if( strcmp( name, "mat_index" ) == 0 )
error = CurNurb_setMatIndex( self, valtuple ); error = CurNurb_setMatIndex( self, valtuple );
else if( strcmp( name, "flagU" ) == 0 ) else if( strcmp( name, "flagU" ) == 0 )
error = CurNurb_setFlagU( self, valtuple ); error = CurNurb_setFlagU( self, valtuple );
else if( strcmp( name, "flagV" ) == 0 ) else if( strcmp( name, "flagV" ) == 0 )
error = CurNurb_setFlagV( self, valtuple ); error = CurNurb_setFlagV( self, valtuple );
else if( strcmp( name, "type" ) == 0 )
error = CurNurb_setType( self, valtuple );
else { /* error - no match for name */ else { /* error - no match for name */
Py_DECREF( valtuple ); Py_DECREF( valtuple );
@@ -368,6 +389,45 @@ static PyObject *M_CurNurb_New( PyObject * self, PyObject * args )
} }
/*
* Curve.getType
*/
static PyObject *CurNurb_getType( BPy_CurNurb * self )
{
/* type is on 3 first bits only */
return PyInt_FromLong( self->nurb->type & 7 );
}
/*
* Curve.setType
*
* Convert the curve using Blender's convertspline fonction
*/
static PyObject *CurNurb_setType( BPy_CurNurb * self, PyObject * args )
{
Nurb *nurb = self->nurb;
int type;
/* parameter type checking */
if( !PyArg_ParseTuple( args, "i", &type ) )
return EXPP_ReturnPyObjError
( PyExc_TypeError, "expected integer argument" );
/* parameter value checking */
if (type != CU_POLY &&
type != CU_BEZIER &&
type != CU_NURBS)
return EXPP_ReturnPyObjError
( PyExc_ValueError, "expected integer argument" );
/* convert and raise error if impossible */
if (convertspline(type, nurb))
return EXPP_ReturnPyObjError
( PyExc_ValueError, "Conversion Impossible" );
return EXPP_incr_ret( Py_None );
}
/* /*
@@ -384,10 +444,10 @@ PyObject *CurNurb_append( BPy_CurNurb * self, PyObject * args )
} }
/* /*
* CurNurb_appendPointToNurb * CurNurb_appendPointToNurb
* this is a non-bpy utility func to add a point to a given nurb * this is a non-bpy utility func to add a point to a given nurb.
* notice the first arg is Nurb*.
*/ */
PyObject *CurNurb_appendPointToNurb( Nurb * nurb, PyObject * args ) PyObject *CurNurb_appendPointToNurb( Nurb * nurb, PyObject * args )
@@ -396,19 +456,37 @@ PyObject *CurNurb_appendPointToNurb( Nurb * nurb, PyObject * args )
int i; int i;
int size; int size;
PyObject *pyOb; PyObject *pyOb;
int npoints; int npoints = nurb->pntsu;
/* /*
do we have a list of four floats or a BezTriple? do we have a list of four floats or a BezTriple?
*/ */
if( !PyArg_ParseTuple( args, "O", &pyOb )) if( !PyArg_ParseTuple( args, "O", &pyOb ))
return( EXPP_ReturnPyObjError return EXPP_ReturnPyObjError
( PyExc_RuntimeError, ( PyExc_RuntimeError,
"Internal error parsing arguments" ) ); "Internal error parsing arguments" );
if( BezTriple_CheckPyObject( pyOb ) ) {
/* if curve is empty, adjust type depending on input type */
if (nurb->bezt==NULL && nurb->bp==NULL) {
if (BezTriple_CheckPyObject( pyOb ))
nurb->type |= CU_BEZIER;
else if (PySequence_Check( pyOb ))
nurb->type |= CU_NURBS;
else
return( EXPP_ReturnPyObjError( PyExc_TypeError,
"Expected a BezTriple or a Sequence of 4 (or 5) floats" ) );
}
if ((nurb->type & 7)==CU_BEZIER) {
BezTriple *tmp; BezTriple *tmp;
npoints = nurb->pntsu;
if( !BezTriple_CheckPyObject( pyOb ) )
return( EXPP_ReturnPyObjError( PyExc_TypeError,
"Expected a BezTriple\n" ) );
/* printf("\ndbg: got a BezTriple\n"); */ /* printf("\ndbg: got a BezTriple\n"); */
tmp = nurb->bezt; /* save old points */ tmp = nurb->bezt; /* save old points */
@@ -430,12 +508,12 @@ PyObject *CurNurb_appendPointToNurb( Nurb * nurb, PyObject * args )
memcpy( nurb->bezt + npoints, memcpy( nurb->bezt + npoints,
BezTriple_FromPyObject( pyOb ), sizeof( BezTriple ) ); BezTriple_FromPyObject( pyOb ), sizeof( BezTriple ) );
} else if( PySequence_Check( pyOb ) ) { }
else if( PySequence_Check( pyOb ) ) {
size = PySequence_Size( pyOb ); size = PySequence_Size( pyOb );
/* printf("\ndbg: got a sequence of size %d\n", size ); */ /* printf("\ndbg: got a sequence of size %d\n", size ); */
if( size == 4 ) { if( size == 4 || size == 5 ) {
BPoint *tmp; BPoint *tmp;
npoints = nurb->pntsu;
tmp = nurb->bp; /* save old pts */ tmp = nurb->bp; /* save old pts */
@@ -465,6 +543,13 @@ PyObject *CurNurb_appendPointToNurb( Nurb * nurb, PyObject * args )
} }
if (size == 5) {
nurb->bp[npoints].alfa = (float)PyFloat_AsDouble( PySequence_GetItem( pyOb, 4 ) );
}
else {
nurb->bp[npoints].alfa = 0.0f;
}
makeknots( nurb, 1, nurb->flagu >> 1 ); makeknots( nurb, 1, nurb->flagu >> 1 );
} else if( size == 3 ) { /* 3 xyz coords */ } else if( size == 3 ) { /* 3 xyz coords */
@@ -474,8 +559,8 @@ PyObject *CurNurb_appendPointToNurb( Nurb * nurb, PyObject * args )
} else { } else {
/* bail with error */ /* bail with error */
return ( EXPP_ReturnPyObjError return EXPP_ReturnPyObjError( PyExc_TypeError,
( PyExc_AttributeError, "expected better stuff" ) ); "expected a sequence of 4 (or optionaly 5) floats\n" );
} }
@@ -727,7 +812,6 @@ static int CurNurb_length( PyInstanceObject * inst )
PyObject *CurNurb_getPoint( BPy_CurNurb * self, int index ) PyObject *CurNurb_getPoint( BPy_CurNurb * self, int index )
{ {
PyObject *pyo;
Nurb *myNurb; Nurb *myNurb;
int npoints; int npoints;
@@ -739,19 +823,89 @@ PyObject *CurNurb_getPoint( BPy_CurNurb * self, int index )
/* DELETED: bail if index < 0 */ /* DELETED: bail if index < 0 */
/* actually, this check is not needed since python treats */ /* actually, this check is not needed since python treats */
/* negative indices as starting from the right end of a sequence */ /* negative indices as starting from the right end of a sequence */
/*
THAT IS WRONG, when passing a negative index, python adjusts it to be positive
BUT it can still overflow in the negatives if the index is too small.
For example, list[-6] when list contains 5 items means index = -1 in here.
(theeth)
*/
/* bail if no Nurbs in Curve */ /* bail if no Nurbs in Curve */
if( npoints == 0 ) if( npoints == 0 )
return ( EXPP_ReturnPyObjError( PyExc_IndexError, return ( EXPP_ReturnPyObjError( PyExc_IndexError,
"no points in this CurNurb" ) ); "no points in this CurNurb" ) );
if( index >= npoints ) /* out of range! */ /* check index limits */
if( index >= npoints || index < 0 )
return ( EXPP_ReturnPyObjError( PyExc_IndexError, return ( EXPP_ReturnPyObjError( PyExc_IndexError,
"index out of range" ) ); "index out of range" ) );
pyo = CurNurb_pointAtIndex( myNurb, index ); return CurNurb_pointAtIndex( myNurb, index );
}
return ( PyObject * ) pyo; /*
* CurNurb_setPoint
* modifies the Nth point in a Nurb
* this is one of the tp_as_sequence methods, hence the int N argument.
* it is called via the [] = operator, not as a usual instance method.
*/
static int CurNurb_setPoint( BPy_CurNurb * self, int index, PyObject * pyOb )
{
Nurb *nurb = self->nurb;
int size;
/* check index limits */
if( index < 0 || index >= nurb->pntsu )
return EXPP_ReturnIntError( PyExc_IndexError,
"array assignment index out of range\n" );
/* branch by curve type */
if ((nurb->type & 7)==CU_BEZIER) { /* BEZIER */
/* check parameter type */
if( !BezTriple_CheckPyObject( pyOb ) )
return EXPP_ReturnIntError( PyExc_TypeError,
"expected a BezTriple\n" );
/* copy bezier in array */
memcpy( nurb->bezt + index,
BezTriple_FromPyObject( pyOb ), sizeof( BezTriple ) );
return 0; /* finished correctly */
}
else { /* NURBS or POLY */
int i;
/* check parameter type */
if (!PySequence_Check( pyOb ))
return EXPP_ReturnIntError( PyExc_TypeError,
"expected a list of 4 (or optionaly 5 if the curve is 3D) floats\n" );
size = PySequence_Size( pyOb );
/* check sequence size */
if( size != 4 && size != 5 )
return EXPP_ReturnIntError( PyExc_TypeError,
"expected a list of 4 (or optionaly 5 if the curve is 3D) floats\n" );
/* copy x, y, z, w */
for( i = 0; i < 4; ++i ) {
float tmpx =
( float ) PyFloat_AsDouble
( PySequence_GetItem( pyOb, i ) );
nurb->bp[index].vec[i] = tmpx;
}
if (size == 5) { /* set tilt, if present */
nurb->bp[index].alfa = (float)PyFloat_AsDouble( PySequence_GetItem( pyOb, 4 ) );
}
else { /* if not, set default */
nurb->bp[index].alfa = 0.0f;
}
return 0; /* finished correctly */
}
} }
@@ -765,15 +919,23 @@ PyObject *CurNurb_pointAtIndex( Nurb * nurb, int index )
if( nurb->bp ) { /* we have a nurb curve */ if( nurb->bp ) { /* we have a nurb curve */
int i; int i;
pyo = PyList_New( 4 );
/* add Tilt only if curve is 3D */
if (nurb->flag & CU_3D)
pyo = PyList_New( 5 );
else
pyo = PyList_New( 4 );
for( i = 0; i < 4; i++ ) { for( i = 0; i < 4; i++ ) {
PyList_SetItem( pyo, i, PyList_SetItem( pyo, i,
PyFloat_FromDouble( nurb->bp[index]. PyFloat_FromDouble( nurb->bp[index].
vec[i] ) ); vec[i] ) );
} }
/* add Tilt only if curve is 3D */
if (nurb->flag & CU_3D)
PyList_SetItem( pyo, 4, PyFloat_FromDouble( nurb->bp[index].alfa ) );
} else if( nurb->bezt ) { /* we have a bezier */ } else if( nurb->bezt ) { /* we have a bezier */
/* if an error occurs, we just pass it on */ /* if an error occurs, we just pass it on */
pyo = BezTriple_CreatePyObject( &( nurb->bezt[index] ) ); pyo = BezTriple_CreatePyObject( &( nurb->bezt[index] ) );
@@ -804,3 +966,76 @@ PyObject *CurNurb_Init( void )
M_CurNurb_doc ); M_CurNurb_doc );
return ( submodule ); return ( submodule );
} }
/*
dump nurb
*/
PyObject *CurNurb_dump( BPy_CurNurb * self )
{
BPoint *bp = NULL;
BezTriple *bezt = NULL;
Nurb *nurb = self->nurb;
int npoints = 0;
if( ! self->nurb ){ /* bail on error */
printf("\n no Nurb in this CurNurb");
Py_RETURN_NONE;
}
printf(" type: %d, mat_nr: %d hide: %d flag: %d",
nurb->type, nurb->mat_nr, nurb->hide, nurb->flag);
printf("\n pntsu: %d, pntsv: %d, resolu: %d resolv: %d",
nurb->pntsu, nurb->pntsv, nurb->resolu, nurb->resolv );
printf("\n orderu: %d orderv: %d", nurb->orderu, nurb->orderv );
printf("\n flagu: %d flagv: %d",
nurb->flagu, nurb->flagv );
npoints = nurb->pntsu;
if( nurb->bp ) { /* we have a BPoint */
int n;
for( n = 0, bp = nurb->bp;
n < npoints;
n++, bp++ )
{
/* vec[4] */
printf( "\ncoords[%d]: ", n);
{
int i;
for( i = 0; i < 4; i++){
printf("%10.3f ", bp->vec[i] );
}
}
/* alfa, s[2] */
printf("\n alpha: %5.2f s: %d %d ",
bp->alfa, bp->s[0], bp->s[1] );
/* f1, hide */
printf(" f1 %d hide %d", bp->f1, bp->hide );
printf("\n");
}
}
else { /* we have a BezTriple */
int n;
for( n = 0, bezt = nurb->bezt;
n < npoints;
n++, bezt++ )
{
int i, j;
printf("\npoint %d: ", n);
for( i = 0; i < 3; i++ ) {
printf("\nvec[%i] ",i );
for( j = 0; j < 3; j++ ) {
printf(" %5.2f ", bezt->vec[i][j] );
}
}
}
printf("\n");
}
Py_RETURN_NONE;
}

28
source/blender/python/api2_2x/Curve.c
View File

@@ -77,6 +77,7 @@ static PyObject *M_Curve_Get( PyObject * self, PyObject * args );
/*****************************************************************************/ /*****************************************************************************/
/* Python BPy_Curve instance methods declarations: */ /* Python BPy_Curve instance methods declarations: */
/*****************************************************************************/ /*****************************************************************************/
PyObject *Curve_getName( BPy_Curve * self ); PyObject *Curve_getName( BPy_Curve * self );
PyObject *Curve_setName( BPy_Curve * self, PyObject * args ); PyObject *Curve_setName( BPy_Curve * self, PyObject * args );
static PyObject *Curve_getPathLen( BPy_Curve * self ); static PyObject *Curve_getPathLen( BPy_Curve * self );
@@ -121,7 +122,7 @@ static PyObject *Curve_setBevOb( BPy_Curve * self, PyObject * args );
static PyObject *Curve_getIter( BPy_Curve * self ); static PyObject *Curve_getIter( BPy_Curve * self );
static PyObject *Curve_iterNext( BPy_Curve * self ); static PyObject *Curve_iterNext( BPy_Curve * self );
static PyObject *Curve_update( BPy_Curve * self );
PyObject *Curve_getNurb( BPy_Curve * self, int n ); PyObject *Curve_getNurb( BPy_Curve * self, int n );
static int Curve_length( PyInstanceObject * inst ); static int Curve_length( PyInstanceObject * inst );
void update_displists( void *data ); void update_displists( void *data );
@@ -476,6 +477,8 @@ PyObject *Curve_setName( BPy_Curve * self, PyObject * args )
PyOS_snprintf( buf, sizeof( buf ), "%s", name ); PyOS_snprintf( buf, sizeof( buf ), "%s", name );
rename_id( &self->curve->id, buf ); /* proper way in Blender */ rename_id( &self->curve->id, buf ); /* proper way in Blender */
Curve_update( self );
Py_INCREF( Py_None ); Py_INCREF( Py_None );
return Py_None; return Py_None;
} }
@@ -1187,6 +1190,12 @@ static PyObject *Curve_appendPoint( BPy_Curve * self, PyObject * args )
} }
/****
appendNurb( new_point )
create a new nurb in the Curve and add the point param to it.
returns a refernce to the newly created nurb.
*****/
static PyObject *Curve_appendNurb( BPy_Curve * self, PyObject * args ) static PyObject *Curve_appendNurb( BPy_Curve * self, PyObject * args )
{ {
Nurb *nurb_ptr = self->curve->nurb.first; Nurb *nurb_ptr = self->curve->nurb.first;
@@ -1210,8 +1219,11 @@ static PyObject *Curve_appendNurb( BPy_Curve * self, PyObject * args )
if( CurNurb_appendPointToNurb( new_nurb, args ) ) { if( CurNurb_appendPointToNurb( new_nurb, args ) ) {
*pptr = new_nurb; *pptr = new_nurb;
new_nurb->resolu = 12; new_nurb->resolu = self->curve->resolu;
new_nurb->resolv = 12; new_nurb->resolv = self->curve->resolv;
new_nurb->hide = 0;
new_nurb->flag = 1;
if( new_nurb->bezt ) { /* do setup for bezt */ if( new_nurb->bezt ) { /* do setup for bezt */
new_nurb->type = CU_BEZIER; new_nurb->type = CU_BEZIER;
@@ -1220,6 +1232,7 @@ static PyObject *Curve_appendNurb( BPy_Curve * self, PyObject * args )
new_nurb->bezt->f1 = 1; new_nurb->bezt->f1 = 1;
new_nurb->bezt->f2 = 1; new_nurb->bezt->f2 = 1;
new_nurb->bezt->f3 = 1; new_nurb->bezt->f3 = 1;
new_nurb->bezt->hide = 0;
/* calchandlesNurb( new_nurb ); */ /* calchandlesNurb( new_nurb ); */
} else { /* set up bp */ } else { /* set up bp */
new_nurb->pntsv = 1; new_nurb->pntsv = 1;
@@ -1228,6 +1241,7 @@ static PyObject *Curve_appendNurb( BPy_Curve * self, PyObject * args )
new_nurb->flagu = 0; new_nurb->flagu = 0;
new_nurb->flagv = 0; new_nurb->flagv = 0;
new_nurb->bp->f1 = 0; new_nurb->bp->f1 = 0;
new_nurb->bp->hide = 0;
new_nurb->knotsu = 0; new_nurb->knotsu = 0;
/*makenots( new_nurb, 1, new_nurb->flagu >> 1); */ /*makenots( new_nurb, 1, new_nurb->flagu >> 1); */
} }
@@ -1237,7 +1251,7 @@ static PyObject *Curve_appendNurb( BPy_Curve * self, PyObject * args )
return NULL; /* with PyErr already set */ return NULL; /* with PyErr already set */
} }
return EXPP_incr_ret( Py_None ); return CurNurb_CreatePyObject( new_nurb );
} }
@@ -1247,10 +1261,10 @@ static PyObject *Curve_appendNurb( BPy_Curve * self, PyObject * args )
* used. after messing with control points * used. after messing with control points
*/ */
static PyObject *Curve_update( BPy_Curve * self ) PyObject *Curve_update( BPy_Curve * self )
{ {
/* update_displists( ( void * ) self->curve ); */ /* update_displists( ( void * ) self->curve ); */
freedisplist( &self->curve->disp ); freedisplist( &self->curve->disp );
Py_INCREF( Py_None ); Py_INCREF( Py_None );
return Py_None; return Py_None;

1
source/blender/python/api2_2x/Curve.h
View File

@@ -56,6 +56,7 @@ PyObject *Curve_Init( void );
PyObject *Curve_CreatePyObject( struct Curve * curve ); PyObject *Curve_CreatePyObject( struct Curve * curve );
int Curve_CheckPyObject( PyObject * py_obj ); int Curve_CheckPyObject( PyObject * py_obj );
struct Curve *Curve_FromPyObject( PyObject * py_obj ); struct Curve *Curve_FromPyObject( PyObject * py_obj );
PyObject *Curve_update( BPy_Curve * self );
PyObject *Curve_getName( BPy_Curve * self ); PyObject *Curve_getName( BPy_Curve * self );
PyObject *Curve_setName( BPy_Curve * self, PyObject * args ); PyObject *Curve_setName( BPy_Curve * self, PyObject * args );

42
source/blender/python/api2_2x/doc/Curve.py
View File

@@ -394,16 +394,36 @@ class CurNurb:
@cvar flagU: The CurNurb knot flag U (0: uniform, 1: endpoints, 2: bezier) @cvar flagU: The CurNurb knot flag U (0: uniform, 1: endpoints, 2: bezier)
@cvar flagV: The CurNurb knot flag V (0: uniform, 1: endpoints, 2: bezier) @cvar flagV: The CurNurb knot flag V (0: uniform, 1: endpoints, 2: bezier)
@cvar type: The type of the curve (Poly: 0, Bezier: 1, NURBS: 4)
""" """
def __setitem__( n, point ):
"""
Replace the Nth point in the curve. The type of the argument must match the type of the curve. List of 4 floats (optional 5th float is the tilt value in radians) for Nurbs or BezTriple for Bezier.
@rtype: PyNone
@return: PyNone
@type n: integer
@param n: the index of the element to replace
@type point: BezTriple or list of 4 floats (optional 5th float is the tilt value in radians)
@param point: the point that will replace the one in the curve. The point can be either a BezTriple type or a list of 4 floats in x,y,z,w (optionally tilt in radians as 5th value) format for a Nurb curve.
"""
def __getitem__( n ):
"""
Get the Nth element in the curve. For Bezier curves, that element is a BezTriple. For the rest (Poly and Nurbs), it is a list of 5 floats: x, y, z, weight, tilt (in radians). NOTE 1: This element element is independant on the curve, modifying it will not affect the curve. NOTE 2: Each successive call returns a new object.
@rtype: BezTriple (Bezier Curve) or List of 5 floats [x, y, z, w, t] for Poly or Nurbs
@return: The Nth element in the curve
@type n: integer
@param n: the index of the element to return
"""
def append( new_point ): def append( new_point ):
""" """
Appends a new point to a curve. This method appends points to both Bezier and Nurb curves. The type of the argument must match the type of the curve. An empty curve will assume the type of the first appended point. Appends a new point to a curve. This method appends points to both Bezier and Nurb curves. The type of the argument must match the type of the curve. List of 4 floats (optional 5th float is the tilt value in radians) for Nurbs or BezTriple for Bezier.
@rtype: PyNone @rtype: PyNone
@return: PyNone @return: PyNone
@type new_point: BezTriple or list of 4 floats @type new_point: BezTriple or list of 4 floats (optional 5th float is the tilt value in radians)
@param new_point: the new point to be appended to the curve. The new point can be either a BezTriple type or a list of 4 floats in x,y,z,w format for a Nurb curve. @param new_point: the new point to be appended to the curve. The new point can be either a BezTriple type or a list of 4 floats in x,y,z,w (optionally tilt in radians as 5th value) format for a Nurb curve.
""" """
def setMatIndex( index ): def setMatIndex( index ):
@@ -467,3 +487,19 @@ class CurNurb:
@rtype: PyNone @rtype: PyNone
@return: PyNone @return: PyNone
""" """
def getType():
"""
Get the type of the curve
@rtype: integer
@return: 0 - Poly, 1 - Bezier, 4 - NURBS
"""
def getType( value ):
"""
Set the type of the curve and converts the curve to its new type if needed
@type value: integer
@param value: CurNurb type flag (0 - Poly, 1 - Bezier, 4 - NURBS)
@rtype: PyNone
@return: PyNone
"""

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

@@ -45,6 +45,7 @@ Their *_Init() method declarations are hacked in down below.
#include "Armature.h" #include "Armature.h"
#include "BezTriple.h"
#include "BGL.h" #include "BGL.h"
#include "Blender.h" #include "Blender.h"
#include "Camera.h" #include "Camera.h"

256
source/blender/src/editcurve.c
View File

@@ -1853,13 +1853,141 @@ void findselectedNurbvert(Nurb **nu, BezTriple **bezt, BPoint **bp)
} }
} }
void setsplinetype(short type) int convertspline(short type, Nurb *nu)
{ {
Nurb *nu;
BezTriple *bezt; BezTriple *bezt;
BPoint *bp; BPoint *bp;
int a, c, nr; int a, c, nr;
if((nu->type & 7)==0) { /* Poly */
if(type==CU_BEZIER) { /* to Bezier with vecthandles */
nr= nu->pntsu;
bezt =
(BezTriple*)MEM_callocN(nr * sizeof(BezTriple), "setsplinetype2");
nu->bezt= bezt;
a= nr;
bp= nu->bp;
while(a--) {
VECCOPY(bezt->vec[1], bp->vec);
bezt->f1=bezt->f2=bezt->f3= bp->f1;
bezt->h1= bezt->h2= HD_VECT;
bp++;
bezt++;
}
MEM_freeN(nu->bp);
nu->bp= 0;
nu->pntsu= nr;
nu->type &= ~7;
nu->type |= 1;
calchandlesNurb(nu);
}
else if(type==4) { /* to Nurb */
nu->type &= ~7;
nu->type+= 4;
nu->orderu= 4;
nu->flagu &= 1;
nu->flagu += 4;
makeknots(nu, 1, nu->flagu>>1);
a= nu->pntsu*nu->pntsv;
bp= nu->bp;
while(a--) {
bp->vec[3]= 1.0;
bp++;
}
}
}
else if((nu->type & 7)==CU_BEZIER) { /* Bezier */
if(type==0 || type==4) { /* to Poly or Nurb */
nr= 3*nu->pntsu;
nu->bp = MEM_callocN(nr * sizeof(BPoint), "setsplinetype");
a= nu->pntsu;
bezt= nu->bezt;
bp= nu->bp;
while(a--) {
if(type==0 && bezt->h1==HD_VECT && bezt->h2==HD_VECT) {
/* vector handle becomes 1 poly vertice */
VECCOPY(bp->vec, bezt->vec[1]);
bp->vec[3]= 1.0;
bp->f1= bezt->f2;
nr-= 2;
bp++;
}
else {
for(c=0;c<3;c++) {
VECCOPY(bp->vec, bezt->vec[c]);
bp->vec[3]= 1.0;
if(c==0) bp->f1= bezt->f1;
else if(c==1) bp->f1= bezt->f2;
else bp->f1= bezt->f3;
bp++;
}
}
bezt++;
}
MEM_freeN(nu->bezt);
nu->bezt= 0;
nu->pntsu= nr;
nu->pntsv= 1;
nu->orderu= 4;
nu->orderv= 1;
nu->type &= ~7;
nu->type+= type;
if(nu->flagu & 1) c= nu->orderu-1;
else c= 0;
if(type== 4) {
nu->flagu &= 1;
nu->flagu += 4;
makeknots(nu, 1, nu->flagu>>1);
}
}
}
else if( (nu->type & 7)==CU_NURBS) {
if(type==0) { /* to Poly */
nu->type &= ~7;
MEM_freeN(nu->knotsu);
nu->knotsu= 0;
if(nu->knotsv) MEM_freeN(nu->knotsv);
nu->knotsv= 0;
}
else if(type==CU_BEZIER) { /* to Bezier */
nr= nu->pntsu/3;
if(nr<2)
return 1; /* conversion impossible */
else {
bezt = MEM_callocN(nr * sizeof(BezTriple), "setsplinetype2");
nu->bezt= bezt;
a= nr;
bp= nu->bp;
while(a--) {
VECCOPY(bezt->vec[0], bp->vec);
bezt->f1= bp->f1;
bp++;
VECCOPY(bezt->vec[1], bp->vec);
bezt->f2= bp->f1;
bp++;
VECCOPY(bezt->vec[2], bp->vec);
bezt->f3= bp->f1;
bp++;
bezt++;
}
MEM_freeN(nu->bp);
nu->bp= 0;
MEM_freeN(nu->knotsu);
nu->knotsu= 0;
nu->pntsu= nr;
nu->type &= ~7;
nu->type+= 1;
}
}
}
return 0;
}
void setsplinetype(short type)
{
Nurb *nu;
if(type==CU_CARDINAL || type==CU_BSPLINE) { if(type==CU_CARDINAL || type==CU_BSPLINE) {
error("Not implemented yet"); error("Not implemented yet");
return; return;
@@ -1868,128 +1996,8 @@ void setsplinetype(short type)
nu= editNurb.first; nu= editNurb.first;
while(nu) { while(nu) {
if(isNurbsel(nu)) { if(isNurbsel(nu)) {
if (convertspline(type, nu))
if((nu->type & 7)==0) { /* Poly */ error("no conversion possible");
if(type==CU_BEZIER) { /* to Bezier with vecthandles */
nr= nu->pntsu;
bezt =
(BezTriple*)MEM_callocN(nr * sizeof(BezTriple), "setsplinetype2");
nu->bezt= bezt;
a= nr;
bp= nu->bp;
while(a--) {
VECCOPY(bezt->vec[1], bp->vec);
bezt->f1=bezt->f2=bezt->f3= bp->f1;
bezt->h1= bezt->h2= HD_VECT;
bp++;
bezt++;
}
MEM_freeN(nu->bp);
nu->bp= 0;
nu->pntsu= nr;
nu->type &= ~7;
nu->type |= 1;
calchandlesNurb(nu);
}
else if(type==4) { /* to Nurb */
nu->type &= ~7;
nu->type+= 4;
nu->orderu= 4;
nu->flagu &= 1;
nu->flagu += 4;
makeknots(nu, 1, nu->flagu>>1);
a= nu->pntsu*nu->pntsv;
bp= nu->bp;
while(a--) {
bp->vec[3]= 1.0;
bp++;
}
}
}
else if((nu->type & 7)==CU_BEZIER) { /* Bezier */
if(type==0 || type==4) { /* to Poly or Nurb */
nr= 3*nu->pntsu;
nu->bp = MEM_callocN(nr * sizeof(BPoint), "setsplinetype");
a= nu->pntsu;
bezt= nu->bezt;
bp= nu->bp;
while(a--) {
if(type==0 && bezt->h1==HD_VECT && bezt->h2==HD_VECT) {
/* vector handle becomes 1 poly vertice */
VECCOPY(bp->vec, bezt->vec[1]);
bp->vec[3]= 1.0;
bp->f1= bezt->f2;
nr-= 2;
bp++;
}
else {
for(c=0;c<3;c++) {
VECCOPY(bp->vec, bezt->vec[c]);
bp->vec[3]= 1.0;
if(c==0) bp->f1= bezt->f1;
else if(c==1) bp->f1= bezt->f2;
else bp->f1= bezt->f3;
bp++;
}
}
bezt++;
}
MEM_freeN(nu->bezt);
nu->bezt= 0;
nu->pntsu= nr;
nu->pntsv= 1;
nu->orderu= 4;
nu->orderv= 1;
nu->type &= ~7;
nu->type+= type;
if(nu->flagu & 1) c= nu->orderu-1;
else c= 0;
if(type== 4) {
nu->flagu &= 1;
nu->flagu += 4;
makeknots(nu, 1, nu->flagu>>1);
}
}
}
else if( (nu->type & 7)==CU_NURBS && G.obedit->type==OB_CURVE) {
if(type==0) { /* to Poly */
nu->type &= ~7;
MEM_freeN(nu->knotsu);
nu->knotsu= 0;
if(nu->knotsv) MEM_freeN(nu->knotsv);
nu->knotsv= 0;
}
else if(type==CU_BEZIER) { /* to Bezier */
nr= nu->pntsu/3;
if(nr<2) error("no conversion possible");
else {
bezt = MEM_callocN(nr * sizeof(BezTriple), "setsplinetype2");
nu->bezt= bezt;
a= nr;
bp= nu->bp;
while(a--) {
VECCOPY(bezt->vec[0], bp->vec);
bezt->f1= bp->f1;
bp++;
VECCOPY(bezt->vec[1], bp->vec);
bezt->f2= bp->f1;
bp++;
VECCOPY(bezt->vec[2], bp->vec);
bezt->f3= bp->f1;
bp++;
bezt++;
}
MEM_freeN(nu->bp);
nu->bp= 0;
MEM_freeN(nu->knotsu);
nu->knotsu= 0;
nu->pntsu= nr;
nu->type &= ~7;
nu->type+= 1;
}
}
}
} }
nu= nu->next; nu= nu->next;
} }