PythonTypes.h

Go to the documentation of this file.

//    Copyright 2004, SenseGraphics AB
//
//    This file is part of H3D API.
//
//    H3D API 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.
//
//    H3D API 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 H3D API; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    A commercial license is also available. Please contact us at 
//    www.sensegraphics.com for more information.
//
//
//
#ifndef __PYTHONTYPES_H__
#define __PYTHONTYPES_H__


#include "Exception.h"
#include "X3DTypes.h"
#include "X3DFieldConversion.h"
#include "Node.h"
#include "H3DApi.h"
#include "PyTypeWrapper.h"

#ifdef HAVE_PYTHON

#if defined(_MSC_VER)
// undefine _DEBUG since we want to always link to the release version of
// python and pyconfig.h automatically links debug version if _DEBUG is
// defined.
#ifdef _DEBUG
#define _DEBUG_UNDEFED
#undef _DEBUG
#endif
#endif
#if defined(__APPLE__) && defined(__MACH__)
#include <Python/Python.h>
#else
#include <Python.h>
#endif
#if defined(_MSC_VER)
// redefine _DEBUG if it was undefed
#ifdef _DEBUG_UNDEFED
#define _DEBUG
#endif
#endif

namespace H3D {

  class PyNodePtr {
  protected:
    Node *ptr;
  };

  // Python C declarations for PyNode type

  extern H3DAPI_API PyTypeObject PyNode_Type;
  inline string PyNode_Name() { return "Node"; }   

  PyObject *PyNode_FromNode( Node *v );

  Node *PyNode_AsNode( PyObject *o );

  inline bool PyNode_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyNode_Type ) || o == Py_None;
  }

  struct PyNode : public PyType, PyNodePtr {

    inline void setNodePtr( Node *_ptr ) {
      if( ptr ) ptr->unref();
      ptr = _ptr;
      if( ptr ) ptr->ref();
    }

    inline Node *nodePtr() {
      return ptr;
    }
    
    static void installType( PyObject* H3D_module );
    
    static PyObject* create(); 
    
    static void dealloc( PyNode *self );

    static int init(PyNode *self, PyObject *args, PyObject *kwds);

    static PyObject* repr( PyNode *myself, PyObject *args);

    static int compare( PyObject *veca, PyObject *vecb );
    
    static PyObject* getField( PyObject *myself, char* arg );

    static PyObject* getFieldList( PyObject *myself );

    static PyObject* getName( PyObject *myself );

    static PyObject* getTypeName( PyObject *myself );

    static PyObject* setName( PyObject *self, PyObject *args );

    static PyObject* getSingleField( PyObject *self, PyObject *args );

    static PyObject* addField( PyObject *self, PyObject *args, 
                               PyObject *field_type, PyObject *access_type );
  };

  // Python C declarations for PyVec2f type

  extern H3DAPI_API PyTypeObject PyVec2f_Type;
  inline string PyVec2f_Name() { return "Vec2f"; }   

  PyObject *PyVec2f_FromVec2f( const Vec2f &v);

  Vec2f PyVec2f_AsVec2f( PyObject *o );

  inline bool PyVec2f_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyVec2f_Type);
  }

  struct PyVec2f : 
        public PyVecTypeWrapper< Vec2f, 
    &PyVec2f_Type,
    PyVec2f_Name,
    PyVec2f_Check,
    PyVec2f_AsVec2f, 
    PyVec2f_FromVec2f >{
    
    static int init(PyVec2f *self, PyObject *args, PyObject *kwds);

    static PyObject* length( PyObject *self, PyObject *args );
    
    static PyObject* lengthSqr( PyObject *self, PyObject *args );

    static PyObject* normalize( PyObject *self, PyObject *args );
    
    static PyObject* normalizeSafe( PyObject *self, PyObject *args );

    static PyObject* dotProduct( PyObject *self, PyObject *args );

  };
  
  // Python C declarations for PyVec2d type

  extern H3DAPI_API PyTypeObject PyVec2d_Type;
  inline string PyVec2d_Name() { return "Vec2d"; }   

  PyObject *PyVec2d_FromVec2d( const Vec2d &v);

  Vec2d PyVec2d_AsVec2d( PyObject *o );

  inline bool PyVec2d_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyVec2d_Type);
  }

  namespace PythonInternals {
    inline bool PyVec2d2f_Check( PyObject *o) {
      return PyObject_TypeCheck(o,&PyVec2d_Type) ||
        PyObject_TypeCheck( o, &PyVec2f_Type );
    }
    
    Vec2d PyVec2d2f_AsVec2d( PyObject *o );
  }
  

  // In the PyVec2d operators a PyVec2f can be used instead of a PyVec2d so we 
  // used the specially defined PyVec2d2f operators for this type.
  struct PyVec2d : 
        public PyVecTypeWrapper< Vec2d, 
    &PyVec2d_Type,
    PyVec2d_Name,
    PythonInternals::PyVec2d2f_Check,
    PythonInternals::PyVec2d2f_AsVec2d, 
    PyVec2d_FromVec2d >{
    
    static int init(PyVec2d *self, PyObject *args, PyObject *kwds);

    static PyObject* length( PyObject *self, PyObject *args );
    
    static PyObject* lengthSqr( PyObject *self, PyObject *args );

    static PyObject* normalize( PyObject *self, PyObject *args );
    
    static PyObject* normalizeSafe( PyObject *self, PyObject *args );

    static PyObject* dotProduct( PyObject *self, PyObject *args );
  };
  
  // Python C declarations for PyVec3f type

  extern H3DAPI_API PyTypeObject PyVec3f_Type;

  inline string PyVec3f_Name() { return "Vec3f"; }   

  PyObject *PyVec3f_FromVec3f( const Vec3f &v);

  Vec3f PyVec3f_AsVec3f( PyObject *o );

  inline bool PyVec3f_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyVec3f_Type);
  }

  struct PyVec3f : 
    public PyVecTypeWrapper< Vec3f, 
    &PyVec3f_Type,
    PyVec3f_Name,
    PyVec3f_Check,
    PyVec3f_AsVec3f, 
    PyVec3f_FromVec3f > {

    static int init(PyVec3f *self, PyObject *args, PyObject *kwds);
    
    static PyObject* mod( PyObject *veca, PyObject *vecb );
    
    static PyObject* length( PyObject *self, PyObject *args );
    
    static PyObject* lengthSqr( PyObject *self, PyObject *args );

    static PyObject* normalize( PyObject *self, PyObject *args );
    
    static PyObject* normalizeSafe( PyObject *self, PyObject *args );

    static PyObject* dotProduct( PyObject *self, PyObject *args );

    static PyObject* crossProduct( PyObject *self, PyObject *args );

  };
  
  // Python C declarations for PyVec3d type

  extern H3DAPI_API PyTypeObject PyVec3d_Type;

  inline string PyVec3d_Name() { return "Vec3d"; }   

  PyObject *PyVec3d_FromVec3d( const Vec3d &v);

  Vec3d PyVec3d_AsVec3d( PyObject *o );

  inline bool PyVec3d_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyVec3d_Type);
  }

  namespace PythonInternals {
    inline bool PyVec3d3f_Check( PyObject *o) {
      return PyObject_TypeCheck(o,&PyVec3d_Type) ||
        PyObject_TypeCheck( o, &PyVec3f_Type );
    }
    
    Vec3d PyVec3d3f_AsVec3d( PyObject *o );
  }


  // In the PyVec3d operators a PyVec3f can be used instead of a PyVec3d so we 
  // used the specially defined PyVec3d3f operators for this type.
  struct PyVec3d : public PyVecTypeWrapper< Vec3d, 
                   &PyVec3d_Type,
                   PyVec3d_Name,
                   PythonInternals::PyVec3d3f_Check,
                   PythonInternals::PyVec3d3f_AsVec3d, 
                   PyVec3d_FromVec3d > {
    static int init(PyVec3d *self, PyObject *args, PyObject *kwds);
    static PyObject* mod( PyObject *veca, PyObject *vecb );
    static PyObject* length( PyObject *self, PyObject *args );
    static PyObject* lengthSqr( PyObject *self, PyObject *args );
    static PyObject* normalize( PyObject *self, PyObject *args );
    static PyObject* normalizeSafe( PyObject *self, PyObject *args );
    static PyObject* dotProduct( PyObject *self, PyObject *args );

    static PyObject* crossProduct( PyObject *self, PyObject *args );
  };
  
  // Python C declarations for PyVec4f type

  extern H3DAPI_API PyTypeObject PyVec4f_Type;

  inline string PyVec4f_Name() { return "Vec4f"; }   

  PyObject *PyVec4f_FromVec4f( const Vec4f &v);

  Vec4f PyVec4f_AsVec4f( PyObject *o );

  inline bool PyVec4f_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyVec4f_Type);
  }

  struct PyVec4f : public PyVecTypeWrapper< Vec4f, 
                   &PyVec4f_Type,
                   PyVec4f_Name,
                   PyVec4f_Check,
                   PyVec4f_AsVec4f, 
                   PyVec4f_FromVec4f > {
    
    static int init(PyVec4f *self, PyObject *args, PyObject *kwds);
  };
  
  
  // Python C declarations for PyVec4d type

  extern H3DAPI_API PyTypeObject PyVec4d_Type;

  inline string PyVec4d_Name() { return "Vec4d"; }   

  PyObject *PyVec4d_FromVec4d( const Vec4d &v);

  Vec4d PyVec4d_AsVec4d( PyObject *o );

  inline bool PyVec4d_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyVec4d_Type);
  }

  namespace PythonInternals {
    inline bool PyVec4d4f_Check( PyObject *o) {
      return PyObject_TypeCheck(o,&PyVec4d_Type) ||
        PyObject_TypeCheck( o, &PyVec4f_Type );
    }
    
    Vec4d PyVec4d4f_AsVec4d( PyObject *o );
  }

  struct PyVec4d : public PyVecTypeWrapper< Vec4d, 
                   &PyVec4d_Type,
                   PyVec4d_Name,
                   PythonInternals::PyVec4d4f_Check,
                   PythonInternals::PyVec4d4f_AsVec4d, 
                   PyVec4d_FromVec4d > {
    
    static int init(PyVec4d *self, PyObject *args, PyObject *kwds);
  };

  // Python C declarations for PyRotation type

  extern H3DAPI_API PyTypeObject PyRotation_Type;

  inline string PyRotation_Name() { return "Rotation"; }   

  PyObject *PyRotation_FromRotation( const Rotation &v);

  Rotation PyRotation_AsRotation( PyObject *o );

  inline bool PyRotation_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyRotation_Type);
  }

  struct PyRotation : public PyNumberTypeWrapper< Rotation, 
                   &PyRotation_Type,
                   PyRotation_Name,
                   PyRotation_Check,
                   PyRotation_AsRotation, 
                   PyRotation_FromRotation > {
  
    static int init(PyRotation *self, PyObject *args, PyObject *kwds);

    static PyObject *toEulerAngles( PyObject *self, PyObject *args );

    static PyObject *slerp( PyObject *self, PyObject *args );

    static PyObject* mul( PyObject *rota, PyObject *rotb );
  };
  
  // Python C declarations for PyQuaternion type
  
  extern H3DAPI_API PyTypeObject PyQuaternion_Type;

  inline string PyQuaternion_Name() { return "Quaternion"; }   

  PyObject *PyQuaternion_FromQuaternion( const Quaternion &v);

  Quaternion PyQuaternion_AsQuaternion( PyObject *o );

  inline bool PyQuaternion_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyQuaternion_Type);
  }

  struct PyQuaternion : public PyNumberTypeWrapper< Quaternion, 
                   &PyQuaternion_Type,
                   PyQuaternion_Name,
                   PyQuaternion_Check,
                   PyQuaternion_AsQuaternion, 
                   PyQuaternion_FromQuaternion > {

    static int init(PyQuaternion *self, PyObject *args, PyObject *kwds);
    
    static PyObject* mul( PyObject *rota, PyObject *rotb );

    static PyObject *toEulerAngles( PyObject *self, PyObject *args );

    static PyObject *norm( PyObject *self, PyObject *args );

    static PyObject* normalize( PyObject *self, PyObject *args );

    static PyObject* conjugate( PyObject *self, PyObject *args );

    static PyObject* inverse( PyObject *self, PyObject *args ); 

    static PyObject* slerp( PyObject *self, PyObject *args ); 

    static PyObject* dotProduct( PyObject *self, PyObject *args ); 
  };

  // Python C declarations for PyMatrix3f type

  extern H3DAPI_API PyTypeObject PyMatrix3f_Type;

  inline string PyMatrix3f_Name() { return "Matrix3f"; }   

  PyObject *PyMatrix3f_FromMatrix3f( const Matrix3f &v);

  Matrix3f PyMatrix3f_AsMatrix3f( PyObject *o );

  inline bool PyMatrix3f_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyMatrix3f_Type);
  }
  struct PyMatrix3f : public PyNumberTypeWrapper< Matrix3f, 
                      &PyMatrix3f_Type,
                      PyMatrix3f_Name,
                      PyMatrix3f_Check,
                      PyMatrix3f_AsMatrix3f, 
                      PyMatrix3f_FromMatrix3f > {
    
    static int init(PyMatrix3f *self, PyObject *args, PyObject *kwds);
    
    static PyObject* mul( PyObject *rota, PyObject *rotb );
    
    static PyObject* setToIdentity( PyObject *self, PyObject *args );

    static PyObject* inverse( PyObject *self, PyObject *args );

    static PyObject* transpose( PyObject *self, PyObject *args );

    static PyObject* toEulerAngles( PyObject *self, PyObject *args );

    static PyObject* getScalePart( PyObject *self, PyObject *args );

    static PyObject* getRow( PyObject *self, PyObject *args );

    static PyObject* getColumn( PyObject *self, PyObject *args );

    static PyObject* getElement( PyObject *self, PyObject *args );

    static PyObject* setElement( PyObject *self, PyObject *args );
  };
    
  // Python C declarations for PyMatrix4f type

  extern H3DAPI_API PyTypeObject PyMatrix4f_Type;

  inline string PyMatrix4f_Name() { return "Matrix4f"; }   

  PyObject *PyMatrix4f_FromMatrix4f( const Matrix4f &v);

  Matrix4f PyMatrix4f_AsMatrix4f( PyObject *o );

  inline bool PyMatrix4f_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyMatrix4f_Type);
  }
  struct PyMatrix4f : public PyNumberTypeWrapper< Matrix4f, 
                      &PyMatrix4f_Type,
                      PyMatrix4f_Name,
                      PyMatrix4f_Check,
                      PyMatrix4f_AsMatrix4f, 
                      PyMatrix4f_FromMatrix4f > {
    
    
    static int init(PyMatrix4f *self, PyObject *args, PyObject *kwds);
    
    static PyObject* mul( PyObject *rota, PyObject *rotb );
    
    static PyObject* setToIdentity( PyObject *self, PyObject *args );

    static PyObject* transformInverse( PyObject *self, PyObject *args );

    static PyObject* inverse( PyObject *self, PyObject *args );

    static PyObject* transpose( PyObject *self, PyObject *args );

    static PyObject* getRow( PyObject *self, PyObject *args );

    static PyObject* getColumn( PyObject *self, PyObject *args );

    static PyObject* getScaleRotationPart( PyObject *self, PyObject *args );

    static PyObject* getRotationPart( PyObject *self, PyObject *args );

    static PyObject* getScalePart( PyObject *self, PyObject *args );

    static PyObject* getElement( PyObject *self, PyObject *args );

    static PyObject* setElement( PyObject *self, PyObject *args );
  };


  // Python C declarations for PyMatrix3d type

  extern H3DAPI_API PyTypeObject PyMatrix3d_Type;

  inline string PyMatrix3d_Name() { return "Matrix3d"; }   

  PyObject *PyMatrix3d_FromMatrix3d( const Matrix3d &v);

  Matrix3d PyMatrix3d_AsMatrix3d( PyObject *o );

  inline bool PyMatrix3d_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyMatrix3d_Type);
  }

  namespace PythonInternals {
    inline bool PyMatrix3d3f_Check( PyObject *o) {
      return PyObject_TypeCheck(o,&PyMatrix3d_Type) ||
        PyObject_TypeCheck( o, &PyMatrix3f_Type );
    }
    
    Matrix3d PyMatrix3d3f_AsMatrix3d( PyObject *o );
  }

  struct PyMatrix3d : public PyNumberTypeWrapper< Matrix3d, 
                      &PyMatrix3d_Type,
                      PyMatrix3d_Name,
                      PythonInternals::PyMatrix3d3f_Check,
                      PythonInternals::PyMatrix3d3f_AsMatrix3d, 
                      PyMatrix3d_FromMatrix3d > {
    
    static int init(PyMatrix3d *self, PyObject *args, PyObject *kwds);
    
    static PyObject* mul( PyObject *rota, PyObject *rotb );
    
    static PyObject* setToIdentity( PyObject *self, PyObject *args );

    static PyObject* inverse( PyObject *self, PyObject *args );

    static PyObject* transpose( PyObject *self, PyObject *args );

    static PyObject* toEulerAngles( PyObject *self, PyObject *args );

    static PyObject* getScalePart( PyObject *self, PyObject *args );

    static PyObject* getRow( PyObject *self, PyObject *args );

    static PyObject* getColumn( PyObject *self, PyObject *args );

    static PyObject* getElement( PyObject *self, PyObject *args );

    static PyObject* setElement( PyObject *self, PyObject *args );
  };
    
  // Python C declarations for PyMatrix4d type

  extern H3DAPI_API PyTypeObject PyMatrix4d_Type;

  inline string PyMatrix4d_Name() { return "Matrix4d"; }   

  PyObject *PyMatrix4d_FromMatrix4d( const Matrix4d &v);

  Matrix4d PyMatrix4d_AsMatrix4d( PyObject *o );

  inline bool PyMatrix4d_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyMatrix4d_Type);
  }

  namespace PythonInternals {
    inline bool PyMatrix4d4f_Check( PyObject *o) {
      return PyObject_TypeCheck(o,&PyMatrix4d_Type) ||
        PyObject_TypeCheck( o, &PyMatrix4f_Type );
    }
    
    Matrix4d PyMatrix4d4f_AsMatrix4d( PyObject *o );
  }

  struct PyMatrix4d : public PyNumberTypeWrapper< Matrix4d, 
                      &PyMatrix4d_Type,
                      PyMatrix4d_Name,
                      PythonInternals::PyMatrix4d4f_Check,
                      PythonInternals::PyMatrix4d4f_AsMatrix4d, 
                      PyMatrix4d_FromMatrix4d > {
    
    
    static int init(PyMatrix4d *self, PyObject *args, PyObject *kwds);
    
    static PyObject* mul( PyObject *rota, PyObject *rotb );
    
    static PyObject* setToIdentity( PyObject *self, PyObject *args );

    static PyObject* transformInverse( PyObject *self, PyObject *args );

    static PyObject* inverse( PyObject *self, PyObject *args );

    static PyObject* transpose( PyObject *self, PyObject *args );

    static PyObject* getRow( PyObject *self, PyObject *args );

    static PyObject* getColumn( PyObject *self, PyObject *args );

    static PyObject* getScaleRotationPart( PyObject *self, PyObject *args );

    static PyObject* getRotationPart( PyObject *self, PyObject *args );

    static PyObject* getScalePart( PyObject *self, PyObject *args );

    static PyObject* getElement( PyObject *self, PyObject *args );

    static PyObject* setElement( PyObject *self, PyObject *args );
  };
    
  // Python C declarations for PyRGB type
  
  extern H3DAPI_API PyTypeObject PyRGB_Type;

  inline string PyRGB_Name() { return "RGB"; }   

  PyObject *PyRGB_FromRGB( const RGB &v);

  RGB PyRGB_AsRGB( PyObject *o );

  inline bool PyRGB_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyRGB_Type);
  }

  struct PyRGB : public PyTypeWrapper< RGB, 
                 &PyRGB_Type,
                 PyRGB_Name,
                 PyRGB_Check,
                 PyRGB_AsRGB, 
                 PyRGB_FromRGB > {
    
    static int init(PyRGB *self, PyObject *args, PyObject *kwds);
  };

  // Python C declarations for PyRGBA type
  
  extern H3DAPI_API PyTypeObject PyRGBA_Type;

  inline string PyRGBA_Name() { return "RGBA"; }   

  PyObject *PyRGBA_FromRGBA( const RGBA &v);

  RGBA PyRGBA_AsRGBA( PyObject *o );

  inline bool PyRGBA_Check( PyObject *o) {
    return PyObject_TypeCheck(o,&PyRGBA_Type);
  }

  struct PyRGBA : public PyTypeWrapper< RGBA, 
                 &PyRGBA_Type,
                 PyRGBA_Name,
                 PyRGBA_Check,
                 PyRGBA_AsRGBA, 
                 PyRGBA_FromRGBA > {
    
    static int init(PyRGBA *self, PyObject *args, PyObject *kwds);
  };
    
}
  
#endif
#endif

---