Logo Search packages:      
Sourcecode: blender version File versions

Metaball.c

/* 
 * $Id: Metaball.c,v 1.18 2004/10/07 19:25:39 stiv Exp $
 *
 * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version. The Blender
 * Foundation also sells licenses for use in proprietary software under
 * the Blender License.  See http://www.blender.org/BL/ for information
 * about this.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 *
 * This is a new part of Blender.
 *
 * Contributor(s): Jacques Guignot
 *
 * ***** END GPL/BL DUAL LICENSE BLOCK *****
 */

#include "Metaball.h"

#include <BKE_main.h>
#include <BKE_global.h>
#include <BKE_mball.h>
#include <BKE_object.h>
#include <BKE_library.h>
#include <BLI_blenlib.h>

#include "constant.h"
#include "gen_utils.h"



/*****************************************************************************/
/* Python API function prototypes for the Metaball module.                   */
/*****************************************************************************/
static PyObject *M_Metaball_New( PyObject * self, PyObject * args );
static PyObject *M_Metaball_Get( PyObject * self, PyObject * args );

/*****************************************************************************/
/* The following string definitions are used for documentation strings.      */
/* In Python these will be written to the console when doing a               */
/* Blender.Metaball.__doc__                                                  */
/*****************************************************************************/
static char M_Metaball_doc[] =
      "The Blender Metaball module\n\n\nMetaballs are spheres\
 that can join each other to create smooth,\
 organic volumes\n. The spheres themseves are called\
 'Metaelements' and can be accessed from the Metaball module.";

static char M_Metaball_New_doc[] = "Creates a new metaball";

static char M_Metaball_Get_doc[] = "Retreives an existing metaball";

/*****************************************************************************/
/* Python method structure definition for Blender.Metaball module:           */
/*****************************************************************************/
struct PyMethodDef M_Metaball_methods[] = {
      {"New", M_Metaball_New, METH_VARARGS, M_Metaball_New_doc},
      {"Get", M_Metaball_Get, METH_VARARGS, M_Metaball_Get_doc},
      {"get", M_Metaball_Get, METH_VARARGS, M_Metaball_Get_doc},
      {NULL, NULL, 0, NULL}
};


/*****************************************************************************/
/* Python BPy_Metaball methods declarations:                                */
/*****************************************************************************/
static PyObject *Metaball_getMetaElemList( BPy_Metaball * self );
static PyObject *Metaball_addMetaelem( BPy_Metaball * self, PyObject * args );
static PyObject *Metaball_getBbox( BPy_Metaball * self );
static PyObject *Metaball_getName( BPy_Metaball * self );
static PyObject *Metaball_setName( BPy_Metaball * self, PyObject * args );
static PyObject *Metaball_getWiresize( BPy_Metaball * self );
static PyObject *Metaball_setWiresize( BPy_Metaball * self, PyObject * args );
static PyObject *Metaball_getRendersize( BPy_Metaball * self );
static PyObject *Metaball_setRendersize( BPy_Metaball * self,
                               PyObject * args );
static PyObject *Metaball_getThresh( BPy_Metaball * self );
static PyObject *Metaball_setThresh( BPy_Metaball * self, PyObject * args );
static PyObject *Metaball_getNMetaElems( BPy_Metaball * self );
static PyObject *Metaball_getMetatype( BPy_Metaball * self, PyObject * args );
static PyObject *Metaball_setMetatype( BPy_Metaball * self, PyObject * args );
static PyObject *Metaball_getMetadata( BPy_Metaball * self, PyObject * args );
static PyObject *Metaball_setMetadata( BPy_Metaball * self, PyObject * args );
static PyObject *Metaball_getMetax( BPy_Metaball * self, PyObject * args );
static PyObject *Metaball_setMetax( BPy_Metaball * self, PyObject * args );
static PyObject *Metaball_getMetay( BPy_Metaball * self, PyObject * args );
static PyObject *Metaball_setMetay( BPy_Metaball * self, PyObject * args );
static PyObject *Metaball_getMetaz( BPy_Metaball * self, PyObject * args );
static PyObject *Metaball_setMetaz( BPy_Metaball * self, PyObject * args );
static PyObject *Metaball_getMetas( BPy_Metaball * self, PyObject * args );
static PyObject *Metaball_setMetas( BPy_Metaball * self, PyObject * args );
static PyObject *Metaball_getMetalen( BPy_Metaball * self, PyObject * args );
static PyObject *Metaball_setMetalen( BPy_Metaball * self, PyObject * args );
static PyObject *Metaball_getloc( BPy_Metaball * self );
static PyObject *Metaball_setloc( BPy_Metaball * self, PyObject * args );
static PyObject *Metaball_getrot( BPy_Metaball * self );
static PyObject *Metaball_setrot( BPy_Metaball * self, PyObject * args );
static PyObject *Metaball_getsize( BPy_Metaball * self );
static PyObject *Metaball_setsize( BPy_Metaball * self, PyObject * args );

/*****************************************************************************/
/* Python BPy_Metaball methods table:                                       */
/*****************************************************************************/
static PyMethodDef BPy_Metaball_methods[] = {
      /* name, method, flags, doc */
      {"getName", ( PyCFunction ) Metaball_getName,
       METH_NOARGS, "() - Return Metaball  name"},

      {"getMetaElemList", ( PyCFunction ) Metaball_getMetaElemList,
       METH_NOARGS, "() - Return Metaelems list"},

      {"addMetaelem", ( PyCFunction ) Metaball_addMetaelem,
       METH_VARARGS, "() -Adds a metaelem to the metaball"},
      {"setName", ( PyCFunction ) Metaball_setName,
       METH_VARARGS, "() - Sets Metaball  name"},
      {"getWiresize", ( PyCFunction ) Metaball_getWiresize,
       METH_NOARGS, "() - Return Metaball  wire size"},
      {"setWiresize", ( PyCFunction ) Metaball_setWiresize,
       METH_VARARGS, "() - Sets Metaball  wire size"},
      {"getRendersize", ( PyCFunction ) Metaball_getRendersize,
       METH_NOARGS, "() - Return Metaball  render size"},
      {"setRendersize", ( PyCFunction ) Metaball_setRendersize,
       METH_VARARGS, "() - Sets Metaball  render size"},
      {"getThresh", ( PyCFunction ) Metaball_getThresh,
       METH_NOARGS, "() - Return Metaball  threshold"},
      {"setThresh", ( PyCFunction ) Metaball_setThresh,
       METH_VARARGS, "() - Sets Metaball  threshold"},
      {"getBbox", ( PyCFunction ) Metaball_getBbox,
       METH_NOARGS, "() - Return Metaball bounding box"},
      {"getNMetaElems", ( PyCFunction ) Metaball_getNMetaElems,
       METH_NOARGS, "() Returns the number of Spheres "},
      {"getMetatype", ( PyCFunction ) Metaball_getMetatype,
       METH_VARARGS, "() - "},
      {"setMetatype", ( PyCFunction ) Metaball_setMetatype,
       METH_VARARGS, "() - "},
      {"getMetadata", ( PyCFunction ) Metaball_getMetadata,
       METH_VARARGS, "() - Gets Metaball MetaData "},
      {"setMetadata", ( PyCFunction ) Metaball_setMetadata,
       METH_VARARGS, "() - "},
      {"getMetax", ( PyCFunction ) Metaball_getMetax,
       METH_VARARGS, "() - gets the x coordinate of the metaelement "},
      {"setMetax", ( PyCFunction ) Metaball_setMetax,
       METH_VARARGS, "() -sets the x coordinate of the metaelement "},
      {"getMetay", ( PyCFunction ) Metaball_getMetay,
       METH_VARARGS, "() - gets the y coordinate of the metaelement"},
      {"setMetay", ( PyCFunction ) Metaball_setMetay,
       METH_VARARGS, "() - sets the y coordinate of the metaelement"},
      {"getMetaz", ( PyCFunction ) Metaball_getMetaz,
       METH_VARARGS, "() - gets the z coordinate of the metaelement"},
      {"setMetaz", ( PyCFunction ) Metaball_setMetaz,
       METH_VARARGS, "() - sets the z coordinate of the metaelement"},
      {"getMetas", ( PyCFunction ) Metaball_getMetas,
       METH_VARARGS, "() - gets the s coordinate of the metaelement"},
      {"setMetas", ( PyCFunction ) Metaball_setMetas,
       METH_VARARGS, "() - sets the s coordinate of the metaelement"},
      {"getMetalen", ( PyCFunction ) Metaball_getMetalen,
       METH_VARARGS, "() -  gets the length of the metaelement."},
      {"setMetalen", ( PyCFunction ) Metaball_setMetalen,
       METH_VARARGS, "() -  sets the length of the metaelement."},
      {"getloc", ( PyCFunction ) Metaball_getloc,
       METH_NOARGS, "() - Gets Metaball loc values"},
      {"setloc", ( PyCFunction ) Metaball_setloc,
       METH_VARARGS, "(f f f) - Sets Metaball loc values"},
      {"getrot", ( PyCFunction ) Metaball_getrot,
       METH_NOARGS, "() - Gets Metaball rot values"},
      {"setrot", ( PyCFunction ) Metaball_setrot,
       METH_VARARGS, "(f f f) - Sets Metaball rot values"},
      {"getsize", ( PyCFunction ) Metaball_getsize,
       METH_NOARGS, "() - Gets Metaball size values"},
      {"setsize", ( PyCFunction ) Metaball_setsize,
       METH_VARARGS, "(f f f) - Sets Metaball size values"},
      {NULL, NULL, 0, NULL}
};

/*****************************************************************************/
/* Python BPy_Metaelem methods table:                                        */
/*****************************************************************************/
static PyMethodDef BPy_Metaelem_methods[] = {
      {NULL, NULL, 0, NULL}
};

/*****************************************************************************/
/* Python Metaball_Type callback function prototypes:                       */
/*****************************************************************************/
static void MetaballDeAlloc( BPy_Metaball * self );
static int MetaballSetAttr( BPy_Metaball * self, char *name, PyObject * v );
static PyObject *MetaballGetAttr( BPy_Metaball * self, char *name );
static PyObject *MetaballRepr( BPy_Metaball * self );

/*****************************************************************************/
/* Python Metaelem_Type callback function prototypes:                        */
/*****************************************************************************/
static void MetaelemDeAlloc( BPy_Metaelem * self );
static int MetaelemSetAttr( BPy_Metaelem * self, char *name, PyObject * v );
static PyObject *MetaelemGetAttr( BPy_Metaelem * self, char *name );
static PyObject *MetaelemRepr( BPy_Metaelem * self );



/*****************************************************************************/
/* Python Metaball_Type structure definition:                                */
/*****************************************************************************/
PyTypeObject Metaball_Type = {
      PyObject_HEAD_INIT( NULL ) 
      0,    /* ob_size */
      "Metaball",       /* tp_name */
      sizeof( BPy_Metaball ), /* tp_basicsize */
      0,                /* tp_itemsize */
      /* methods */
      ( destructor ) MetaballDeAlloc,     /* tp_dealloc */
      0,                /* tp_print */
      ( getattrfunc ) MetaballGetAttr,    /* tp_getattr */
      ( setattrfunc ) MetaballSetAttr,    /* tp_setattr */
      0,                /* tp_compare */
      ( reprfunc ) MetaballRepr,    /* tp_repr */
      0,                /* tp_as_number */
      0,                /* tp_as_sequence */
      0,                /* tp_as_mapping */
      0,                /* tp_as_hash */
      0, 0, 0, 0, 0, 0,
      0,                /* tp_doc */
      0, 0, 0, 0, 0, 0,
      BPy_Metaball_methods,   /* tp_methods */
      0,                /* tp_members */
};


PyTypeObject Metaelem_Type = {
      PyObject_HEAD_INIT( NULL ) 
      0,    /* ob_size */
      "Metaelem",       /* tp_name */
      sizeof( BPy_Metaelem ), /* tp_basicsize */
      0,                /* tp_itemsize */
      /* methods */
      ( destructor ) MetaelemDeAlloc,     /* tp_dealloc */
      0,                /* tp_print */
      ( getattrfunc ) MetaelemGetAttr,    /* tp_getattr */
      ( setattrfunc ) MetaelemSetAttr,    /* tp_setattr */
      0,                /* tp_compare */
      ( reprfunc ) MetaelemRepr,    /* tp_repr */
      0,                /* tp_as_number */
      0,                /* tp_as_sequence */
      0,                /* tp_as_mapping */
      0,                /* tp_as_hash */
      0, 0, 0, 0, 0, 0,
      0,                /* tp_doc */
      0, 0, 0, 0, 0, 0,
      BPy_Metaelem_methods,   /* tp_methods */
      0,                /* tp_members */
};

/*****************************************************************************/
/* Function:              M_Metaball_New                                     */
/* Python equivalent:     Blender.Metaball.New                               */
/*****************************************************************************/
static PyObject *M_Metaball_New( PyObject * self, PyObject * args )
{
      char *name = 0;
      BPy_Metaball *pymball;  /* for Data object wrapper in Python */
      MetaBall *blmball;      /* for actual Data we create in Blender */
      char buf[21];
      if( !PyArg_ParseTuple( args, "|s", &name ) )
            return ( EXPP_ReturnPyObjError( PyExc_TypeError,
                                    "expected string argument (or nothing)" ) );

      blmball = add_mball(  );      /* first create the MetaBall Data in Blender */

      if( blmball ) {
            /* return user count to zero since add_mball() incref'ed it */
            blmball->id.us = 0;
            /* now create the wrapper obj in Python */
            pymball =
                  ( BPy_Metaball * ) PyObject_NEW( BPy_Metaball,
                                           &Metaball_Type );
      } else
            return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
                                    "couldn't create MetaBall Data in Blender" ) );

      if( pymball == NULL )
            return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
                                    "couldn't create MetaBall Data object" ) );

      pymball->metaball = blmball;
      /*link Python mballer wrapper to Blender MetaBall */
      if( name ) {            /* user gave us a name for the metaball, use it */
            PyOS_snprintf( buf, sizeof( buf ), "%s", name );
            rename_id( &blmball->id, buf );
      }
      return ( PyObject * ) pymball;
}


/*****************************************************************************/
/* Function:             M_Metaball_Get                                     */
/* Python equivalent:    Blender.Metaball.Get                               */
/* Description:          Receives a string and returns the metaball data obj */
/*                       whose name matches the string.  If no argument is  */
/*                       passed in, a list of all metaball data names in the */
/*                       current scene is returned.                         */
/*****************************************************************************/
static PyObject *M_Metaball_Get( PyObject * self, PyObject * args )
{
      char error_msg[64];
      char *name = NULL;
      MetaBall *mball_iter;

      if( !PyArg_ParseTuple( args, "|s", &name ) )
            return ( EXPP_ReturnPyObjError( PyExc_TypeError,
                                    "expected string argument (or nothing)" ) );

      mball_iter = G.main->mball.first;

      if( name ) {            /* (name) - Search mball by name */

            BPy_Metaball *wanted_mball = NULL;

            while( ( mball_iter ) && ( wanted_mball == NULL ) ) {
                  if( strcmp( name, mball_iter->id.name + 2 ) == 0 ) {
                        wanted_mball =
                              ( BPy_Metaball * )
                              PyObject_NEW( BPy_Metaball,
                                          &Metaball_Type );
                        if( wanted_mball )
                              wanted_mball->metaball = mball_iter;
                  }
                  mball_iter = mball_iter->id.next;
            }

            if( wanted_mball == NULL ) {  /* Requested mball doesn't exist */
                  PyOS_snprintf( error_msg, sizeof( error_msg ),
                               "MetaBall \"%s\" not found", name );
                  return ( EXPP_ReturnPyObjError
                         ( PyExc_NameError, error_msg ) );
            }

            return ( PyObject * ) wanted_mball;
      }

      else {                  /* () - return a list of all mballs in the scene */
            PyObject *mballlist;

            mballlist = PyList_New( 0 );

            if( mballlist == NULL )
                  return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
                                          "couldn't create PyList" ) );

            while( mball_iter ) {
                  BPy_Metaball *found_mball =
                        ( BPy_Metaball * ) PyObject_NEW( BPy_Metaball,
                                                 &Metaball_Type );
                  found_mball->metaball = mball_iter;
                  PyList_Append( mballlist, ( PyObject * ) found_mball );
                  mball_iter = mball_iter->id.next;
            }

            return ( mballlist );
      }

}

/****************************************************************************/
/* Function:            Metaball_Init                                       */
/****************************************************************************/
PyObject *Metaball_Init( void )
{
      PyObject *submodule;

      Metaball_Type.ob_type = &PyType_Type;

      submodule = Py_InitModule3( "Blender.Metaball",
                            M_Metaball_methods, M_Metaball_doc );

      return ( submodule );
}

int Metaball_CheckPyObject( PyObject * pyobj )
{
      return ( pyobj->ob_type == &Metaball_Type );
}


MetaBall *Metaball_FromPyObject( PyObject * pyobj )
{
      return ( ( BPy_Metaball * ) pyobj )->metaball;
}

/***************************************************************************/
/* Python BPy_Metaball methods:                                            */
/***************************************************************************/
void *MEM_callocN( unsigned int, char * );
void allqueue( unsigned short, short );

static PyObject *Metaball_addMetaelem( BPy_Metaball * self, PyObject * args )
{
      MetaElem *ml;
      PyObject *listargs = 0;
      int type, lay;
      float x, y, z, rad, s, expx, expy, expz;
      if( !PyArg_ParseTuple( args, "O", &listargs ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected a list" ) );
      if( !PyList_Check( listargs ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected a list" ) );


      type = PyInt_AsLong( PyList_GetItem( listargs, 0 ) );
      x = PyFloat_AsDouble( PyList_GetItem( listargs, 1 ) );
      y = PyFloat_AsDouble( PyList_GetItem( listargs, 2 ) );
      z = PyFloat_AsDouble( PyList_GetItem( listargs, 3 ) );
      rad = PyFloat_AsDouble( PyList_GetItem( listargs, 4 ) );
      lay = PyInt_AsLong( PyList_GetItem( listargs, 5 ) );
      s = PyFloat_AsDouble( PyList_GetItem( listargs, 6 ) );
      expx = PyFloat_AsDouble( PyList_GetItem( listargs, 7 ) );
      expy = PyFloat_AsDouble( PyList_GetItem( listargs, 8 ) );
      expz = PyFloat_AsDouble( PyList_GetItem( listargs, 9 ) );

      ml = MEM_callocN( sizeof( MetaElem ), "metaelem" );
      BLI_addhead( &( self->metaball->elems ), ml );

      ml->x = x;
      ml->y = y;
      ml->z = z;
      ml->rad = rad;
      ml->lay = lay;
      ml->s = s;
      ml->flag = SELECT;
      ml->type = type;
      ml->expx = expx;
      ml->expy = expy;
      ml->expz = expz;
      ml->type = type;
      allqueue( 0X4013, 0 );
      Py_INCREF( Py_None );
      return Py_None;
}

static PyObject *Metaball_getName( BPy_Metaball * self )
{

      PyObject *attr = PyString_FromString( self->metaball->id.name + 2 );

      if( attr )
            return attr;

      return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
                              "couldn't get Metaball.name attribute" ) );
}



static PyObject *Metaball_setName( BPy_Metaball * self, PyObject * args )
{
      char *name = NULL;
      char buf[20];


      if( !PyArg_ParseTuple( args, "s", &name ) )
            return ( EXPP_ReturnPyObjError( PyExc_TypeError,
                                    "expected string argument" ) );
      PyOS_snprintf( buf, sizeof( buf ), "%s", name );
      rename_id( &self->metaball->id, buf );
      Py_INCREF( Py_None );
      return Py_None;
}





static PyObject *Metaball_getBbox( BPy_Metaball * self )
{
      int i, j;
      PyObject *ll;
      PyObject *l = PyList_New( 0 );
      if( self->metaball->bb == NULL ) {
            Py_INCREF( Py_None );
            return Py_None;
      }
      for( i = 0; i < 8; i++ ) {
            ll = PyList_New( 0 );
            for( j = 0; j < 3; j++ )
                  PyList_Append( ll,
                               PyFloat_FromDouble( self->metaball->bb->
                                             vec[i][j] ) );
            PyList_Append( l, ll );
      }

      return l;
}

static PyObject *Metaball_getNMetaElems( BPy_Metaball * self )
{
      int i = 0;
      MetaElem *ptr = self->metaball->elems.first;
      if( !ptr )
            return ( PyInt_FromLong( 0 ) );
      while( ptr ) {
            i++;
            ptr = ptr->next;
      }
      return ( PyInt_FromLong( i ) );
}




static PyObject *Metaball_getloc( BPy_Metaball * self )
{
      PyObject *l = PyList_New( 0 );
      PyList_Append( l, PyFloat_FromDouble( self->metaball->loc[0] ) );
      PyList_Append( l, PyFloat_FromDouble( self->metaball->loc[1] ) );
      PyList_Append( l, PyFloat_FromDouble( self->metaball->loc[2] ) );
      return l;
}

static PyObject *Metaball_setloc( BPy_Metaball * self, PyObject * args )
{
      PyObject *listargs = 0;
      int i;
      if( !PyArg_ParseTuple( args, "O", &listargs ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected a list" ) );
      if( !PyList_Check( listargs ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected a list" ) );
      for( i = 0; i < 3; i++ ) {
            PyObject *xx = PyList_GetItem( listargs, i );
            self->metaball->loc[i] = PyFloat_AsDouble( xx );
      }
      Py_INCREF( Py_None );
      return Py_None;
}

static PyObject *Metaball_getrot( BPy_Metaball * self )
{
      PyObject *l = PyList_New( 0 );
      PyList_Append( l, PyFloat_FromDouble( self->metaball->rot[0] ) );
      PyList_Append( l, PyFloat_FromDouble( self->metaball->rot[1] ) );
      PyList_Append( l, PyFloat_FromDouble( self->metaball->rot[2] ) );
      return l;
}

static PyObject *Metaball_setrot( BPy_Metaball * self, PyObject * args )
{
      PyObject *listargs = 0;
      int i;
      if( !PyArg_ParseTuple( args, "O", &listargs ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected a list" ) );
      if( !PyList_Check( listargs ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected a list" ) );
      for( i = 0; i < 3; i++ ) {
            PyObject *xx = PyList_GetItem( listargs, i );
            self->metaball->rot[i] = PyFloat_AsDouble( xx );
      }
      Py_INCREF( Py_None );
      return Py_None;
}

static PyObject *Metaball_getsize( BPy_Metaball * self )
{
      PyObject *l = PyList_New( 0 );

      PyList_Append( l, PyFloat_FromDouble( self->metaball->size[0] ) );
      PyList_Append( l, PyFloat_FromDouble( self->metaball->size[1] ) );
      PyList_Append( l, PyFloat_FromDouble( self->metaball->size[2] ) );
      return l;
}




static PyObject *Metaball_getMetaElemList( BPy_Metaball * self )
{
      MetaElem *ptr;
      PyObject *l = PyList_New( 0 );
      ptr = self->metaball->elems.first;
      if( !ptr )
            return l;
      while( ptr ) {
            BPy_Metaelem *found_melem =
                  ( BPy_Metaelem * ) PyObject_NEW( BPy_Metaelem,
                                           &Metaelem_Type );
            found_melem->metaelem = ptr;
            PyList_Append( l, ( PyObject * ) found_melem );
            ptr = ptr->next;
      }
      return l;
}


static PyObject *Metaball_setsize( BPy_Metaball * self, PyObject * args )
{
      PyObject *listargs = 0;
      int i;
      if( !PyArg_ParseTuple( args, "O", &listargs ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected a list" ) );
      if( !PyList_Check( listargs ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected a list" ) );
      for( i = 0; i < 3; i++ ) {
            PyObject *xx = PyList_GetItem( listargs, i );
            self->metaball->size[i] = PyFloat_AsDouble( xx );
      }
      Py_INCREF( Py_None );
      return Py_None;
}

static PyObject *Metaball_getWiresize( BPy_Metaball * self )
{
      return PyFloat_FromDouble( self->metaball->wiresize );
}

static PyObject *Metaball_setWiresize( BPy_Metaball * self, PyObject * args )
{

      float val;
      if( !PyArg_ParseTuple( args, "f", &val ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected float args" ) );

      self->metaball->wiresize = val;

      Py_INCREF( Py_None );
      return Py_None;

}
static PyObject *Metaball_getRendersize( BPy_Metaball * self )
{
      return PyFloat_FromDouble( self->metaball->rendersize );
}

static PyObject *Metaball_setRendersize( BPy_Metaball * self, PyObject * args )
{

      float val;
      if( !PyArg_ParseTuple( args, "f", &val ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected float args" ) );

      self->metaball->rendersize = val;

      Py_INCREF( Py_None );
      return Py_None;

}
static PyObject *Metaball_getThresh( BPy_Metaball * self )
{
      return PyFloat_FromDouble( self->metaball->thresh );
}

static PyObject *Metaball_setThresh( BPy_Metaball * self, PyObject * args )
{

      float val;
      if( !PyArg_ParseTuple( args, "f", &val ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected float args" ) );

      self->metaball->thresh = val;

      Py_INCREF( Py_None );
      return Py_None;

}


/**************************************************************************/
/* get/set metaelems data,                                                */
/***************************************************************************/

static PyObject *Metaball_getMetadata( BPy_Metaball * self, PyObject * args )
{
      int num;
      int i = 0;
      char *name = NULL;
      MetaElem *ptr;

      if( !PyArg_ParseTuple( args, "si", &name, &num ) )
            return ( EXPP_ReturnPyObjError( PyExc_TypeError,
                                    "expected (string int) argument" ) );
      /*jump to the num-th MetaElem */
      ptr = self->metaball->elems.first;
      if( !ptr )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "no metaelem found" ) );
      for( i = 0; i < num; i++ ) {
            if( !ptr )
                  return ( EXPP_ReturnPyObjError
                         ( PyExc_TypeError, "metaelem not found" ) );
            ptr = ptr->next;
      }
      if( !strcmp( name, "type" ) )
            return ( PyInt_FromLong( ptr->type ) );
      if( !strcmp( name, "x" ) )
            return ( PyFloat_FromDouble( ptr->x ) );
      if( !strcmp( name, "y" ) )
            return ( PyFloat_FromDouble( ptr->y ) );
      if( !strcmp( name, "z" ) )
            return ( PyFloat_FromDouble( ptr->z ) );
      if( !strcmp( name, "expx" ) )
            return ( PyFloat_FromDouble( ptr->expx ) );
      if( !strcmp( name, "expy" ) )
            return ( PyFloat_FromDouble( ptr->expy ) );
      if( !strcmp( name, "expz" ) )
            return ( PyFloat_FromDouble( ptr->expz ) );
      if( !strcmp( name, "rad" ) )
            return ( PyFloat_FromDouble( ptr->rad ) );
      if( !strcmp( name, "rad2" ) )
            return ( PyFloat_FromDouble( ptr->rad2 ) );
      if( !strcmp( name, "s" ) )
            return ( PyFloat_FromDouble( ptr->s ) );
      if( !strcmp( name, "len" ) )
            return ( PyFloat_FromDouble( ptr->len ) );

      return ( EXPP_ReturnPyObjError( PyExc_TypeError, "unknown name " ) );
}



static PyObject *Metaball_setMetadata( BPy_Metaball * self, PyObject * args )
{
      int num;
      int i = 0;
      char *name = NULL;
      int intval = -1;
      float floatval = 0;
      MetaElem *ptr;

      if( !PyArg_ParseTuple( args, "sif", &name, &num, &floatval ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError,
                     "expected string, int, float arguments" ) );
      intval = ( int ) floatval;
      printf( "%f %d %s %d\n", floatval, intval, name, num );
      /*jump to the num-th MetaElem */
      ptr = self->metaball->elems.first;
      if( !ptr )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "metaelem not found" ) );
      for( i = 0; i < num; i++ ) {
            if( !ptr )
                  return ( EXPP_ReturnPyObjError
                         ( PyExc_TypeError, "metaelem not found" ) );
            ptr = ptr->next;
      }
      if( !strcmp( name, "type" ) ) {
            ptr->type = intval;
            return ( PyInt_FromLong( intval ) );
      }
      if( !strcmp( name, "x" ) ) {
            ptr->x = floatval;
            printf( "%p %f\n", ptr, floatval );
            return ( PyFloat_FromDouble( floatval ) );
      }
      if( !strcmp( name, "y" ) ) {
            ptr->y = floatval;
            return ( PyFloat_FromDouble( floatval ) );
      }
      if( !strcmp( name, "z" ) ) {
            ptr->z = floatval;
            return ( PyFloat_FromDouble( floatval ) );
      }
      if( !strcmp( name, "expx" ) ) {
            ptr->expx = floatval;
            return ( PyFloat_FromDouble( floatval ) );
      }
      if( !strcmp( name, "expy" ) ) {
            ptr->expy = floatval;
            return ( PyFloat_FromDouble( floatval ) );
      }
      if( !strcmp( name, "expz" ) ) {
            ptr->expz = floatval;
            return ( PyFloat_FromDouble( floatval ) );
      }
      if( !strcmp( name, "rad" ) ) {
            ptr->rad = floatval;
            return ( PyFloat_FromDouble( floatval ) );
      }
      if( !strcmp( name, "rad2" ) ) {
            ptr->rad2 = floatval;
            return ( PyFloat_FromDouble( floatval ) );
      }
      if( !strcmp( name, "s" ) ) {
            ptr->s = floatval;
            return ( PyFloat_FromDouble( floatval ) );
      }
      if( !strcmp( name, "len" ) ) {
            ptr->len = floatval;
            return ( PyFloat_FromDouble( floatval ) );
      }

      return ( EXPP_ReturnPyObjError( PyExc_TypeError, "unknown field " ) );
}

static PyObject *Metaball_getMetatype( BPy_Metaball * self, PyObject * args )
{
      int num;
      int i = 0;
      MetaElem *ptr = self->metaball->elems.first;
      if( !PyArg_ParseTuple( args, "i", &num ) )
            return ( EXPP_ReturnPyObjError( PyExc_TypeError,
                                    "expected int argument" ) );
      if( !ptr )
            return ( PyInt_FromLong( 0 ) );
      for( i = 0; i < num; i++ ) {
            ptr = ptr->next;
      }
      return ( PyInt_FromLong( ptr->type ) );
}



static PyObject *Metaball_setMetatype( BPy_Metaball * self, PyObject * args )
{
      int num, val, i = 0;
      MetaElem *ptr = self->metaball->elems.first;
      if( !PyArg_ParseTuple( args, "ii", &num, &val ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected int int arguments" ) );
      if( !ptr )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "No MetaElem" ) );
      for( i = 0; i < num; i++ ) {
            ptr = ptr->next;
      }
      ptr->type = val;

      Py_INCREF( Py_None );
      return Py_None;

}


static PyObject *Metaball_getMetax( BPy_Metaball * self, PyObject * args )
{
      MetaElem *ptr = self->metaball->elems.first;
      int num;
      int i = 0;
      if( !PyArg_ParseTuple( args, "i", &num ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected int argument" ) );
      if( !ptr )
            return ( PyFloat_FromDouble( 0 ) );
      for( i = 0; i < num; i++ ) {
            ptr = ptr->next;
      }
      return ( PyFloat_FromDouble( ptr->x ) );
}



static PyObject *Metaball_setMetax( BPy_Metaball * self, PyObject * args )
{
      MetaElem *ptr = self->metaball->elems.first;
      int num, i = 0;
      float val;
      if( !PyArg_ParseTuple( args, "if", &num, &val ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected int float args" ) );
      if( !ptr )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "No MetaElem" ) );
      for( i = 0; i < num; i++ ) {
            ptr = ptr->next;
      }
      ptr->x = val;

      Py_INCREF( Py_None );
      return Py_None;

}
static PyObject *Metaball_getMetay( BPy_Metaball * self, PyObject * args )
{
      MetaElem *ptr = self->metaball->elems.first;
      int num;
      int i = 0;
      if( !PyArg_ParseTuple( args, "i", &num ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected int argument" ) );
      if( !ptr )
            return ( PyFloat_FromDouble( 0 ) );
      for( i = 0; i < num; i++ ) {
            ptr = ptr->next;
      }
      return ( PyFloat_FromDouble( ptr->y ) );
}



static PyObject *Metaball_setMetay( BPy_Metaball * self, PyObject * args )
{
      MetaElem *ptr = self->metaball->elems.first;
      int num, i = 0;
      float val;
      if( !PyArg_ParseTuple( args, "if", &num, &val ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected int float args" ) );
      if( !ptr )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "No MetaElem" ) );
      for( i = 0; i < num; i++ ) {
            ptr = ptr->next;
      }
      ptr->y = val;

      Py_INCREF( Py_None );
      return Py_None;

}


static PyObject *Metaball_getMetaz( BPy_Metaball * self, PyObject * args )
{
      MetaElem *ptr = self->metaball->elems.first;
      int num;
      int i = 0;
      if( !PyArg_ParseTuple( args, "i", &num ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected int argument" ) );
      if( !ptr )
            return ( PyFloat_FromDouble( 0 ) );
      for( i = 0; i < num; i++ ) {
            ptr = ptr->next;
      }
      return ( PyFloat_FromDouble( ptr->z ) );
}

static PyObject *Metaball_setMetaz( BPy_Metaball * self, PyObject * args )
{
      int num, i = 0;
      MetaElem *ptr = self->metaball->elems.first;
      float val;
      if( !PyArg_ParseTuple( args, "if", &num, &val ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected int float args" ) );
      if( !ptr )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "No MetaElem" ) );
      for( i = 0; i < num; i++ ) {
            ptr = ptr->next;
      }
      ptr->z = val;

      Py_INCREF( Py_None );
      return Py_None;

}


static PyObject *Metaball_getMetas( BPy_Metaball * self, PyObject * args )
{
      MetaElem *ptr = self->metaball->elems.first;
      int num;
      int i = 0;
      if( !PyArg_ParseTuple( args, "i", &num ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected int argument" ) );
      if( !ptr )
            return ( PyFloat_FromDouble( 0 ) );
      for( i = 0; i < num; i++ ) {
            ptr = ptr->next;
      }
      return ( PyFloat_FromDouble( ptr->s ) );
}

static PyObject *Metaball_setMetas( BPy_Metaball * self, PyObject * args )
{
      int num, i = 0;
      MetaElem *ptr = self->metaball->elems.first;
      float val;
      if( !PyArg_ParseTuple( args, "if", &num, &val ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected int float args" ) );
      if( !ptr )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "No MetaElem" ) );
      for( i = 0; i < num; i++ ) {
            ptr = ptr->next;
      }
      ptr->s = val;

      Py_INCREF( Py_None );
      return Py_None;

}






static PyObject *Metaball_getMetalen( BPy_Metaball * self, PyObject * args )
{
      int num;
      int i = 0;
      MetaElem *ptr;

      if( !PyArg_ParseTuple( args, "i", &num ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected int argument" ) );
      ptr = self->metaball->elems.first;
      if( !ptr )
            return ( PyFloat_FromDouble( 0 ) );
      for( i = 0; i < num; i++ ) {
            ptr = ptr->next;
      }
      return ( PyFloat_FromDouble( ptr->len ) );
}

static PyObject *Metaball_setMetalen( BPy_Metaball * self, PyObject * args )
{
      int num, i = 0;
      float val;
      MetaElem *ptr;

      if( !PyArg_ParseTuple( args, "if", &num, &val ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected int float args" ) );
      ptr = self->metaball->elems.first;
      if( !ptr )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "No MetaElem" ) );
      for( i = 0; i < num; i++ ) {
            ptr = ptr->next;
      }
      ptr->len = val;

      Py_INCREF( Py_None );
      return Py_None;
}



/*****************************************************************************/
/* Function:    MetaballDeAlloc                                              */
/* Description: This is a callback function for the BPy_Metaball type. It is */
/*              the destructor function.                                     */
/*****************************************************************************/
static void MetaballDeAlloc( BPy_Metaball * self )
{
      PyObject_DEL( self );
}


/*****************************************************************************/
/* Function:    MetaelemDeAlloc                                              */
/* Description: This is a callback function for the BPy_Metaelem type. It is */
/*              the destructor function.                                     */
/*****************************************************************************/
static void MetaelemDeAlloc( BPy_Metaelem * self )
{
      PyObject_DEL( self );
}




/*****************************************************************************/
/* Function:    MetaballGetAttr                                              */
/* Description: This is a callback function for the BPy_Metaball type. It is */
/*              the function that accesses BPy_Metaball "member variables" */
/*              and   methods.                                               */
/*****************************************************************************/
static PyObject *MetaballGetAttr( BPy_Metaball * self, char *name )
{

      if( strcmp( name, "name" ) == 0 )
            return Metaball_getName( self );
      if( strcmp( name, "rot" ) == 0 )
            return Metaball_getrot( self );
      if( strcmp( name, "loc" ) == 0 )
            return Metaball_getloc( self );
      if( strcmp( name, "size" ) == 0 )
            return Metaball_getsize( self );
      return Py_FindMethod( BPy_Metaball_methods, ( PyObject * ) self,
                        name );
}



/****************************************************************************/
/* Function:    MetaballSetAttr                                             */
/* Description: This is a callback function for the BPy_Metaball type.      */
/*              It sets Metaball Data attributes       (member variables).*/
/****************************************************************************/
static int MetaballSetAttr( BPy_Metaball * self, char *name, PyObject * value )
{
      PyObject *valtuple = Py_BuildValue( "(O)", value );

      if( !valtuple )
            return EXPP_ReturnIntError( PyExc_MemoryError,
                                  "MetaballSetAttr: couldn't create PyTuple" );

      if( strcmp( name, "name" ) == 0 ) {
            Metaball_setName( self, valtuple );
            return 0;
      }

      if( strcmp( name, "rot" ) == 0 ) {
            Metaball_setrot( self, valtuple );
            return 0;
      }
      if( strcmp( name, "loc" ) == 0 ) {
            Metaball_setloc( self, valtuple );
            return 0;
      }

      if( strcmp( name, "size" ) == 0 ) {
            Metaball_setsize( self, valtuple );
            return 0;
      }
      return ( EXPP_ReturnIntError
             ( PyExc_KeyError, "attribute not found" ) );
}








static PyObject *Metaelem_getdims( BPy_Metaelem * self )
{
      PyObject *l = PyList_New( 0 );
      PyList_Append( l, PyFloat_FromDouble( self->metaelem->expx ) );
      PyList_Append( l, PyFloat_FromDouble( self->metaelem->expy ) );
      PyList_Append( l, PyFloat_FromDouble( self->metaelem->expz ) );
      return l;
}


static PyObject *Metaelem_setdims( BPy_Metaelem * self, PyObject * args )
{

      PyObject *listargs = 0;
      if( !PyArg_ParseTuple( args, "O", &listargs ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected a list" ) );
      if( !PyList_Check( listargs ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected a list" ) );
      self->metaelem->expx =
            PyFloat_AsDouble( PyList_GetItem( listargs, 0 ) );
      self->metaelem->expy =
            PyFloat_AsDouble( PyList_GetItem( listargs, 1 ) );
      self->metaelem->expz =
            PyFloat_AsDouble( PyList_GetItem( listargs, 2 ) );
      Py_INCREF( Py_None );
      return Py_None;
}



static PyObject *Metaelem_getcoords( BPy_Metaelem * self )
{
      PyObject *l = PyList_New( 0 );
      PyList_Append( l, PyFloat_FromDouble( self->metaelem->x ) );
      PyList_Append( l, PyFloat_FromDouble( self->metaelem->y ) );
      PyList_Append( l, PyFloat_FromDouble( self->metaelem->z ) );
      return l;
}


static PyObject *Metaelem_setcoords( BPy_Metaelem * self, PyObject * args )
{

      PyObject *listargs = 0;
      if( !PyArg_ParseTuple( args, "O", &listargs ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected a list" ) );
      if( !PyList_Check( listargs ) )
            return ( EXPP_ReturnPyObjError
                   ( PyExc_TypeError, "expected a list" ) );
      self->metaelem->x = PyFloat_AsDouble( PyList_GetItem( listargs, 0 ) );
      self->metaelem->y = PyFloat_AsDouble( PyList_GetItem( listargs, 1 ) );
      self->metaelem->z = PyFloat_AsDouble( PyList_GetItem( listargs, 2 ) );
      Py_INCREF( Py_None );
      return Py_None;
}


/***************************************************************************/
/* Function:    MetaelemGetAttr                                          */
/* Description: This is a callback function for the BPy_Metaelem type.   */
/*              It  accesses BPy_Metaelem "member variables".            */
/*****************************************************************************/
static PyObject *MetaelemGetAttr( BPy_Metaelem * self, char *name )
{

      if( !strcmp( name, "dims" ) )
            return Metaelem_getdims( self );
      if( !strcmp( name, "coords" ) )
            return Metaelem_getcoords( self );
      if( !strcmp( name, "rad" ) )
            return PyFloat_FromDouble( self->metaelem->rad );
      if( !strcmp( name, "stif" ) )
            return PyFloat_FromDouble( self->metaelem->s );
      return Py_FindMethod( BPy_Metaelem_methods, ( PyObject * ) self,
                        name );
}



/*****************************************************************************/
/* Function:    MetaelemSetAttr                                            */
/* Description: This is a callback function for the BPy_Metaelem type.   */
/*               It sets Metaelem Data attributes (member variables).      */
/****************************************************************************/
static int MetaelemSetAttr( BPy_Metaelem * self, char *name, PyObject * value )
{

      if( !strcmp( name, "coords" ) ) {
            PyObject *valtuple = Py_BuildValue( "(O)", value );
            if( !valtuple )
                  return EXPP_ReturnIntError( PyExc_MemoryError,
                                        "MetaelemSetAttr: couldn't create PyTuple" );
            Metaelem_setcoords( self, valtuple );
            return 0;
      }
      if( !strcmp( name, "dims" ) ) {
            PyObject *valtuple = Py_BuildValue( "(O)", value );
            if( !valtuple )
                  return EXPP_ReturnIntError( PyExc_MemoryError,
                                        "MetaelemSetAttr: couldn't create PyTuple" );
            Metaelem_setdims( self, valtuple );
            return 0;
      }
      if( !strcmp( name, "rad" ) ) {
            self->metaelem->rad = PyFloat_AsDouble( value );
            return 0;
      }
      if( !strcmp( name, "stif" ) ) {
            self->metaelem->s = PyFloat_AsDouble( value );
            return 0;
      }
      return ( EXPP_ReturnIntError
             ( PyExc_KeyError, "attribute not found" ) );
}

/****************************************************************************/
/* Function:    MetaballRepr                                                */
/* Description: This is a callback function for the BPy_Metaball type. It   */
/*              builds a meaninful string to represent metaball objects.    */
/****************************************************************************/
static PyObject *MetaballRepr( BPy_Metaball * self )
{
      return PyString_FromFormat( "[Metaball \"%s\"]",
                            self->metaball->id.name + 2 );
}


/****************************************************************************/
/* Function:    MetaelemRepr                                               */
/* Description: This is a callback function for the BPy_Metaelem type. It   */
/*              builds a meaninful string to represent metaelem objects.    */
/*****************************************************************************/
static PyObject *MetaelemRepr( BPy_Metaelem * self )
{
      return PyString_FromString( "Metaelem" );
}

Generated by  Doxygen 1.6.0   Back to index