/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3.24
 * 
 * This file is not intended to be easily readable and contains a number of 
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG 
 * interface file instead. 
 * ----------------------------------------------------------------------------- */

#define SWIGPYTHON

#ifdef __cplusplus
template<class T> class SwigValueWrapper {
    T *tt;
public:
    SwigValueWrapper() : tt(0) { }
    SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
    SwigValueWrapper(const T& t) : tt(new T(t)) { }
    ~SwigValueWrapper() { delete tt; } 
    SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
    operator T&() const { return *tt; }
    T *operator&() { return tt; }
private:
    SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
};
#endif


#ifndef SWIG_TEMPLATE_DISAMBIGUATOR
#  if defined(__SUNPRO_CC) 
#    define SWIG_TEMPLATE_DISAMBIGUATOR template
#  else
#    define SWIG_TEMPLATE_DISAMBIGUATOR 
#  endif
#endif



    #ifndef __STDC_CONSTANT_MACROS
    #define __STDC_CONSTANT_MACROS
    #endif
    #ifndef __STDC_LIMIT_MACROS
    #define __STDC_LIMIT_MACROS
    #endif
    #ifndef DEBUG_PYTHON
    #undef _DEBUG
    #endif
    #include <Python.h>

/***********************************************************************
 * swigrun.swg
 *
 *     This file contains generic CAPI SWIG runtime support for pointer
 *     type checking.
 *
 ************************************************************************/

/* This should only be incremented when either the layout of swig_type_info changes,
   or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "1"

/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
#define SWIG_QUOTE_STRING(x) #x
#define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
#define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
#define SWIG_TYPE_TABLE_NAME
#endif

#include <string.h>

#ifndef SWIGINLINE
#if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#  define SWIGINLINE inline
#else
#  define SWIGINLINE
#endif
#endif

/*
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
  creating a static or dynamic library from the swig runtime code.
  In 99.9% of the cases, swig just needs to declare them as 'static'.
  
  But only do this if is strictly necessary, ie, if you have problems
  with your compiler or so.
*/
#ifndef SWIGRUNTIME
#define SWIGRUNTIME static
#endif
#ifndef SWIGRUNTIMEINLINE
#define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

#ifdef __cplusplus
extern "C" {
#endif

typedef void *(*swig_converter_func)(void *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);

typedef struct swig_type_info {
  const char             *name;
  swig_converter_func     converter;
  const char             *str;
  void                   *clientdata;
  swig_dycast_func        dcast;
  struct swig_type_info  *next;
  struct swig_type_info  *prev;
} swig_type_info;

/* 
  Compare two type names skipping the space characters, therefore
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.

  Return 0 when the two name types are equivalent, as in
  strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
		  const char *f2, const char *l2) {
  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
    while ((*f1 == ' ') && (f1 != l1)) ++f1;
    while ((*f2 == ' ') && (f2 != l2)) ++f2;
    if (*f1 != *f2) return *f1 - *f2;
  }
  return (l1 - f1) - (l2 - f2);
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
  int equiv = 0;
  const char* te = tb + strlen(tb);
  const char* ne = nb;
  while (!equiv && *ne) {
    for (nb = ne; *ne; ++ne) {
      if (*ne == '|') break;
    }
    equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
    if (*ne) ++ne;
  }
  return equiv;
}

/*
  Register a type mapping with the type-checking
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
  swig_type_info *tc, *head, *ret, *next;
  /* Check to see if this type has already been registered */
  tc = *tl;
  while (tc) {
    /* check simple type equivalence */
    int typeequiv = (strcmp(tc->name, ti->name) == 0);   
    /* check full type equivalence, resolving typedefs */
    if (!typeequiv) {
      /* only if tc is not a typedef (no '|' on it) */
      if (tc->str && ti->str && !strstr(tc->str,"|")) {
	typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
      }
    }
    if (typeequiv) {
      /* Already exists in the table.  Just add additional types to the list */
      if (ti->clientdata) tc->clientdata = ti->clientdata;
      head = tc;
      next = tc->next;
      goto l1;
    }
    tc = tc->prev;
  }
  head = ti;
  next = 0;

  /* Place in list */
  ti->prev = *tl;
  *tl = ti;

  /* Build linked lists */
  l1:
  ret = head;
  tc = ti + 1;
  /* Patch up the rest of the links */
  while (tc->name) {
    head->next = tc;
    tc->prev = head;
    head = tc;
    tc++;
  }
  if (next) next->prev = head;
  head->next = next;

  return ret;
}

/*
  Check the typename
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
  swig_type_info *s;
  if (!ty) return 0;        /* Void pointer */
  s = ty->next;             /* First element always just a name */
  do {
    if (strcmp(s->name,c) == 0) {
      if (s == ty->next) return s;
      /* Move s to the top of the linked list */
      s->prev->next = s->next;
      if (s->next) {
        s->next->prev = s->prev;
      }
      /* Insert s as second element in the list */
      s->next = ty->next;
      if (ty->next) ty->next->prev = s;
      ty->next = s;
      s->prev = ty;
      return s;
    }
    s = s->next;
  } while (s && (s != ty->next));
  return 0;
}

/*
  Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_type_info *ty, void *ptr) {
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
}

/* 
   Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
  swig_type_info *lastty = ty;
  if (!ty || !ty->dcast) return ty;
  while (ty && (ty->dcast)) {
    ty = (*ty->dcast)(ptr);
    if (ty) lastty = ty;
  }
  return lastty;
}

/*
  Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
  return ty->name;
}

/*
  Return the pretty name associated with this type,
  that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
  /* The "str" field contains the equivalent pretty names of the
     type, separated by vertical-bar characters.  We choose
     to print the last name, as it is often (?) the most
     specific. */
  if (type->str != NULL) {
    const char *last_name = type->str;
    const char *s;
    for (s = type->str; *s; s++)
      if (*s == '|') last_name = s+1;
    return last_name;
  }
  else
    return type->name;
}

/*
  Search for a swig_type_info structure
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
  swig_type_info *ty = tl;
  while (ty) {
    if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
    if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
    ty = ty->prev;
  }
  return 0;
}

/* 
   Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
  swig_type_info *tc, *equiv;
  if (ti->clientdata) return;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;
  equiv = ti->next;
  while (equiv) {
    if (!equiv->converter) {
      tc = tl;
      while (tc) {
        if ((strcmp(tc->name, equiv->name) == 0))
          SWIG_TypeClientDataTL(tl,tc,clientdata);
        tc = tc->prev;
      }
    }
    equiv = equiv->next;
  }
}

/* 
   Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
  static char hex[17] = "0123456789abcdef";
  unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu =  u + sz;
  register unsigned char uu;
  for (; u != eu; ++u) {
    uu = *u;
    *(c++) = hex[(uu & 0xf0) >> 4];
    *(c++) = hex[uu & 0xf];
  }
  return c;
}

/* 
   Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
  register unsigned char *u = (unsigned char *) ptr;
  register const unsigned char *eu =  u + sz;
  for (; u != eu; ++u) {
    register int d = *(c++);
    register unsigned char uu = 0;
    if ((d >= '0') && (d <= '9'))
      uu = ((d - '0') << 4);
    else if ((d >= 'a') && (d <= 'f'))
      uu = ((d - ('a'-10)) << 4);
    else 
      return (char *) 0;
    d = *(c++);
    if ((d >= '0') && (d <= '9'))
      uu |= (d - '0');
    else if ((d >= 'a') && (d <= 'f'))
      uu |= (d - ('a'-10));
    else 
      return (char *) 0;
    *u = uu;
  }
  return c;
}

/*
  This function will propagate the clientdata field of type to any new
  swig_type_info structures that have been added into the list of
  equivalent types.  It is like calling SWIG_TypeClientData(type,
  clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
  swig_type_info *equiv = type->next;
  swig_type_info *tc;
  if (!type->clientdata) return;
  while (equiv) {
    if (!equiv->converter) {
      tc = tl;
      while (tc) {
        if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
          SWIG_TypeClientDataTL(tl,tc, type->clientdata);
        tc = tc->prev;
      }
    }
    equiv = equiv->next;
  }
}

/* 
   Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
  char *r = buff;
  if ((2*sizeof(void *) + 2) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,&ptr,sizeof(void *));
  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
  strcpy(r,name);
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      *ptr = (void *) 0;
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sizeof(void *));
}

SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
  char *r = buff;
  size_t lname = (name ? strlen(name) : 0);
  if ((2*sz + 2 + lname) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,ptr,sz);
  if (lname) {
    strncpy(r,name,lname+1);
  } else {
    *r = 0;
  }
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      memset(ptr,0,sz);
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sz);
}

#ifdef __cplusplus
}
#endif

/***********************************************************************
 * common.swg
 *
 *     This file contains generic SWIG runtime support for pointer
 *     type checking as well as a few commonly used macros to control
 *     external linkage.
 *
 * Author : David Beazley (beazley@cs.uchicago.edu)
 *
 * Copyright (c) 1999-2000, The University of Chicago
 * 
 * This file may be freely redistributed without license or fee provided
 * this copyright message remains intact.
 ************************************************************************/


#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#  if !defined(STATIC_LINKED)
#    define SWIGEXPORT(a) __declspec(dllexport) a
#  else
#    define SWIGEXPORT(a) a
#  endif
#else
#  define SWIGEXPORT(a) a
#endif

#ifdef __cplusplus
extern "C" {
#endif


/*************************************************************************/


/* The static type info list */

static swig_type_info *swig_type_list = 0;
static swig_type_info **swig_type_list_handle = &swig_type_list;
  

/* Register a type mapping with the type-checking */
static swig_type_info *
SWIG_TypeRegister(swig_type_info *ti) {
  return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
}

/* Search for a swig_type_info structure */
static swig_type_info *
SWIG_TypeQuery(const char *name) {
  return SWIG_TypeQueryTL(*swig_type_list_handle, name);
}

/* Set the clientdata field for a type */
static void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
static void
SWIG_PropagateClientData(swig_type_info *type) {
  SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
}

#ifdef __cplusplus
}
#endif

/* -----------------------------------------------------------------------------
 * SWIG API. Portion that goes into the runtime
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#endif

/* -----------------------------------------------------------------------------
 * for internal method declarations
 * ----------------------------------------------------------------------------- */

#ifndef SWIGINTERN
#define SWIGINTERN static 
#endif

#ifndef SWIGINTERNSHORT
#ifdef __cplusplus
#define SWIGINTERNSHORT static inline 
#else /* C case */
#define SWIGINTERNSHORT static 
#endif /* __cplusplus */
#endif


/*
  Exception handling in wrappers
*/
#define SWIG_fail                goto fail
#define SWIG_arg_fail(arg)       SWIG_Python_ArgFail(arg)
#define SWIG_append_errmsg(msg)   SWIG_Python_AddErrMesg(msg,0)
#define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
#define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
#define SWIG_null_ref(type)       SWIG_Python_NullRef(type)

/*
  Contract support
*/
#define SWIG_contract_assert(expr, msg) \
 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else

/* -----------------------------------------------------------------------------
 * Constant declarations
 * ----------------------------------------------------------------------------- */

/* Constant Types */
#define SWIG_PY_INT     1
#define SWIG_PY_FLOAT   2
#define SWIG_PY_STRING  3
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY  5

/* Constant information structure */
typedef struct swig_const_info {
    int type;
    char *name;
    long lvalue;
    double dvalue;
    void   *pvalue;
    swig_type_info **ptype;
} swig_const_info;


/* -----------------------------------------------------------------------------
 * Alloc. memory flags
 * ----------------------------------------------------------------------------- */
#define SWIG_OLDOBJ  1
#define SWIG_NEWOBJ  SWIG_OLDOBJ + 1
#define SWIG_PYSTR   SWIG_NEWOBJ + 1

#ifdef __cplusplus
}
#endif


/***********************************************************************
 * pyrun.swg
 *
 *     This file contains the runtime support for Python modules
 *     and includes code for managing global variables and pointer
 *     type checking.
 *
 * Author : David Beazley (beazley@cs.uchicago.edu)
 ************************************************************************/

/* Common SWIG API */
#define SWIG_ConvertPtr(obj, pp, type, flags)    SWIG_Python_ConvertPtr(obj, pp, type, flags)
#define SWIG_NewPointerObj(p, type, flags)       SWIG_Python_NewPointerObj(p, type, flags)
#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
 

/* Python-specific SWIG API */
#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags)   SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
#define SWIG_NewPackedObj(ptr, sz, type)              SWIG_Python_NewPackedObj(ptr, sz, type)


/* -----------------------------------------------------------------------------
 * Pointer declarations
 * ----------------------------------------------------------------------------- */
/*
  Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
  C/C++ pointers in the python side. Very useful for debugging, but
  not always safe.
*/
#if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
#  define SWIG_COBJECT_TYPES
#endif

/* Flags for pointer conversion */
#define SWIG_POINTER_EXCEPTION     0x1
#define SWIG_POINTER_DISOWN        0x2


#ifdef __cplusplus
extern "C" {
#endif

/* -----------------------------------------------------------------------------
 * Create a new pointer string 
 * ----------------------------------------------------------------------------- */

#ifndef SWIG_BUFFER_SIZE
#define SWIG_BUFFER_SIZE 1024
#endif

#if defined(SWIG_COBJECT_TYPES)
#if !defined(SWIG_COBJECT_PYTHON)
/* -----------------------------------------------------------------------------
 * Implements a simple Swig Object type, and use it instead of PyCObject
 * ----------------------------------------------------------------------------- */

typedef struct {
  PyObject_HEAD
  void *ptr;
  const char *desc;
} PySwigObject;

/* Declarations for objects of type PySwigObject */

SWIGRUNTIME int
PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
    fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
    return 0; 
  } else {
    return 1; 
  }
}
  
SWIGRUNTIME PyObject *
PySwigObject_repr(PySwigObject *v)
{
  char result[SWIG_BUFFER_SIZE];
  return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
    PyString_FromFormat("<Swig Object at %s>", result) : 0;
}

SWIGRUNTIME PyObject *
PySwigObject_str(PySwigObject *v)
{
  char result[SWIG_BUFFER_SIZE];
  return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
    PyString_FromString(result) : 0;
}

SWIGRUNTIME PyObject *
PySwigObject_long(PySwigObject *v)
{
  return PyLong_FromUnsignedLong((unsigned long) v->ptr);
}

SWIGRUNTIME PyObject *
PySwigObject_oct(PySwigObject *v)
{
  char buf[100];
  unsigned long x = (unsigned long)v->ptr;
  if (x == 0)
    strcpy(buf, "0");
  else
    PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
  return PyString_FromString(buf);
}

SWIGRUNTIME PyObject *
PySwigObject_hex(PySwigObject *v)
{
  char buf[100];
  PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
  return PyString_FromString(buf);
}

SWIGRUNTIME int
PySwigObject_compare(PySwigObject *v, PySwigObject *w)
{
  int c = strcmp(v->desc, w->desc);
  if (c) {
    return c;
  } else {
    void *i = v->ptr;
    void *j = w->ptr;
    return (i < j) ? -1 : (i > j) ? 1 : 0;
  }
}

SWIGRUNTIME void
PySwigObject_dealloc(PySwigObject *self)
{
  PyObject_DEL(self);
}

SWIGRUNTIME PyTypeObject*
PySwigObject_GetType() {
  static char PySwigObject_Type__doc__[] = 
    "Swig object carries a C/C++ instance pointer";
  
  static PyNumberMethods PySwigObject_as_number = {
    (binaryfunc)0, /*nb_add*/
    (binaryfunc)0, /*nb_subtract*/
    (binaryfunc)0, /*nb_multiply*/
    (binaryfunc)0, /*nb_divide*/
    (binaryfunc)0, /*nb_remainder*/
    (binaryfunc)0, /*nb_divmod*/
    (ternaryfunc)0,/*nb_power*/
    (unaryfunc)0,  /*nb_negative*/
    (unaryfunc)0,  /*nb_positive*/
    (unaryfunc)0,  /*nb_absolute*/
    (inquiry)0,    /*nb_nonzero*/
    0,		   /*nb_invert*/
    0,		   /*nb_lshift*/
    0,		   /*nb_rshift*/
    0,		   /*nb_and*/
    0,		   /*nb_xor*/
    0,		   /*nb_or*/
    (coercion)0,   /*nb_coerce*/
    (unaryfunc)PySwigObject_long, /*nb_int*/
    (unaryfunc)PySwigObject_long, /*nb_long*/
    (unaryfunc)0,                 /*nb_float*/
    (unaryfunc)PySwigObject_oct,  /*nb_oct*/
    (unaryfunc)PySwigObject_hex,  /*nb_hex*/
#if PY_VERSION_HEX >= 0x02000000
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ 
#endif
  };

  static int type_init = 0;  
  static PyTypeObject PySwigObject_Type;

  if (!type_init) {
    PyTypeObject tmp = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,					/*ob_size*/
    "PySwigObject",			/*tp_name*/
    sizeof(PySwigObject),		/*tp_basicsize*/
    0,					/*tp_itemsize*/
    /* methods */
    (destructor)PySwigObject_dealloc,	/*tp_dealloc*/
    (printfunc)PySwigObject_print,	/*tp_print*/
    (getattrfunc)0,			/*tp_getattr*/
    (setattrfunc)0,			/*tp_setattr*/
    (cmpfunc)PySwigObject_compare,	/*tp_compare*/
    (reprfunc)PySwigObject_repr,	/*tp_repr*/
    &PySwigObject_as_number,	        /*tp_as_number*/
    0,					/*tp_as_sequence*/
    0,					/*tp_as_mapping*/
    (hashfunc)0,			/*tp_hash*/
    (ternaryfunc)0,			/*tp_call*/
    (reprfunc)PySwigObject_str,		/*tp_str*/
    /* Space for future expansion */
    0L,0L,0L,0L,
    PySwigObject_Type__doc__, 	        /* Documentation string */
#if PY_VERSION_HEX >= 0x02000000
    0,                                  /* tp_traverse */
    0,                                  /* tp_clear */
#endif
#if PY_VERSION_HEX >= 0x02010000
    0,                                  /* tp_richcompare */
    0,                                  /* tp_weaklistoffset */
#endif
#if PY_VERSION_HEX >= 0x02020000
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
    0,                                  /* tp_del */
#endif
#ifdef COUNT_ALLOCS
    0,0,0,0                             /* tp_alloc -> tp_next */
#endif
    };

    PySwigObject_Type = tmp;
    type_init = 1;
  }

  return &PySwigObject_Type;
}

SWIGRUNTIME PyObject *
PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
{
  PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
  if (self == NULL) return NULL;
  self->ptr = ptr;
  self->desc = desc;
  return (PyObject *)self;
}

SWIGRUNTIMEINLINE void *
PySwigObject_AsVoidPtr(PyObject *self)
{
  return ((PySwigObject *)self)->ptr;
}

SWIGRUNTIMEINLINE const char *
PySwigObject_GetDesc(PyObject *self)
{
  return ((PySwigObject *)self)->desc;
}

SWIGRUNTIMEINLINE int
PySwigObject_Check(PyObject *op) {
  return ((op)->ob_type == PySwigObject_GetType()) 
    || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
}

/* -----------------------------------------------------------------------------
 * Implements a simple Swig Packed type, and use it instead of string
 * ----------------------------------------------------------------------------- */

typedef struct {
  PyObject_HEAD
  void *pack;
  const char *desc;
  size_t size;
} PySwigPacked;

SWIGRUNTIME int
PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
{
  char result[SWIG_BUFFER_SIZE];
  fputs("<Swig Packed ", fp); 
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    fputs("at ", fp); 
    fputs(result, fp); 
  }
  fputs(v->desc,fp); 
  fputs(">", fp);
  return 0; 
}
  
SWIGRUNTIME PyObject *
PySwigPacked_repr(PySwigPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
  } else {
    return PyString_FromFormat("<Swig Packed %s>", v->desc);
  }  
}

SWIGRUNTIME PyObject *
PySwigPacked_str(PySwigPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
    return PyString_FromFormat("%s%s", result, v->desc);
  } else {
    return PyString_FromFormat("%s", v->desc);
  }  
}

SWIGRUNTIME int
PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
{
  int c = strcmp(v->desc, w->desc);
  if (c) {
    return c;
  } else {
    size_t i = v->size;
    size_t j = w->size;
    int s = (i < j) ? -1 : (i > j) ? 1 : 0;
    return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
  }
}

SWIGRUNTIME void
PySwigPacked_dealloc(PySwigPacked *self)
{
  free(self->pack);
  PyObject_DEL(self);
}

SWIGRUNTIME PyTypeObject*
PySwigPacked_GetType() {
  static char PySwigPacked_Type__doc__[] = 
    "Swig object carries a C/C++ instance pointer";
  static int type_init = 0;
  
  static PyTypeObject PySwigPacked_Type;
  if (!type_init) {
    PyTypeObject tmp = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,					/*ob_size*/
    "PySwigPacked",			/*tp_name*/
    sizeof(PySwigPacked),		/*tp_basicsize*/
    0,					/*tp_itemsize*/
    /* methods */
    (destructor)PySwigPacked_dealloc,	/*tp_dealloc*/
    (printfunc)PySwigPacked_print,	/*tp_print*/
    (getattrfunc)0,			/*tp_getattr*/
    (setattrfunc)0,			/*tp_setattr*/
    (cmpfunc)PySwigPacked_compare,	/*tp_compare*/
    (reprfunc)PySwigPacked_repr,	/*tp_repr*/
    0,	                                /*tp_as_number*/
    0,					/*tp_as_sequence*/
    0,					/*tp_as_mapping*/
    (hashfunc)0,			/*tp_hash*/
    (ternaryfunc)0,			/*tp_call*/
    (reprfunc)PySwigPacked_str,		/*tp_str*/
    /* Space for future expansion */
    0L,0L,0L,0L,
    PySwigPacked_Type__doc__, 	        /* Documentation string */
#if PY_VERSION_HEX >= 0x02000000
    0,                                  /* tp_traverse */
    0,                                  /* tp_clear */
#endif
#if PY_VERSION_HEX >= 0x02010000
    0,                                  /* tp_richcompare */
    0,                                  /* tp_weaklistoffset */
#endif
#if PY_VERSION_HEX >= 0x02020000         
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
    0,                                  /* tp_del */
#endif
#ifdef COUNT_ALLOCS
    0,0,0,0                             /* tp_alloc -> tp_next */
#endif
    };

    PySwigPacked_Type = tmp;
    type_init = 1;
  }
  
      

  return &PySwigPacked_Type;
}

SWIGRUNTIME PyObject *
PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
{
  PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
  if (self == NULL) {
    return NULL;
  } else {
    void *pack = malloc(size);
    memcpy(pack, ptr, size);
    self->pack = pack;
    self->desc = desc;
    self->size = size;
    return (PyObject *) self;
  }
}

SWIGRUNTIMEINLINE const char *
PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
  PySwigPacked *self = (PySwigPacked *)obj;
  if (self->size != size) return 0;
  memcpy(ptr, self->pack, size);
  return self->desc;
}

SWIGRUNTIMEINLINE const char *
PySwigPacked_GetDesc(PyObject *self)
{
  return ((PySwigPacked *)self)->desc;
}

SWIGRUNTIMEINLINE int
PySwigPacked_Check(PyObject *op) {
  return ((op)->ob_type == PySwigPacked_GetType()) 
    || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
}

#else
/* -----------------------------------------------------------------------------
 * Use the old Python PyCObject instead of PySwigObject
 * ----------------------------------------------------------------------------- */

#define PySwigObject_GetDesc(obj)	           PyCObject_GetDesc(obj)
#define PySwigObject_Check(obj)	           PyCObject_Check(obj)
#define PySwigObject_AsVoidPtr(obj)	   PyCObject_AsVoidPtr(obj)
#define PySwigObject_FromVoidPtrAndDesc(p, d)  PyCObject_FromVoidPtrAndDesc(p, d, NULL)

#endif

#endif

/* -----------------------------------------------------------------------------
 * errors manipulation
 * ----------------------------------------------------------------------------- */

SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
  if (type) {
#if defined(SWIG_COBJECT_TYPES)
    if (PySwigObject_Check(obj)) {
      const char *otype = (const char *) PySwigObject_GetDesc(obj);
      if (otype) {
	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
		     type, otype);
	return;
      }
    } else 
#endif      
    {
      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
      if (otype) {
	PyObject *str = PyObject_Str(obj);
	const char *cstr = str ? PyString_AsString(str) : 0;
	if (cstr) {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
		       type, otype, cstr);
	} else {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
		       type, otype);
	}
	Py_DECREF(str);
	return;
      }
    }   
    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
  } else {
    PyErr_Format(PyExc_TypeError, "unexpected type is received");
  }
}

SWIGRUNTIMEINLINE void
SWIG_Python_NullRef(const char *type)
{
  if (type) {
    PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
  } else {
    PyErr_Format(PyExc_TypeError, "null reference was received");
  }
}

SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{
  if (PyErr_Occurred()) {
    PyObject *type = 0;
    PyObject *value = 0;
    PyObject *traceback = 0;
    PyErr_Fetch(&type, &value, &traceback);
    if (value) {
      PyObject *old_str = PyObject_Str(value);
      Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
      } else {
	PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
      }
      Py_DECREF(old_str);
    }
    return 1;
  } else {
    return 0;
  }
}

SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
  if (PyErr_Occurred()) {
    /* add information about failing argument */
    char mesg[256];
    sprintf(mesg, "argument number %d:", argnum);
    return SWIG_Python_AddErrMesg(mesg, 1);
  } else {
    return 0;
  }
}


/* -----------------------------------------------------------------------------
 * pointers/data manipulation
 * ----------------------------------------------------------------------------- */

/* Convert a pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
  swig_type_info *tc;
  const char *c = 0;
  static PyObject *SWIG_this = 0;
  int    newref = 0;
  PyObject  *pyobj = 0;
  void *vptr;
  
  if (!obj) return 0;
  if (obj == Py_None) {
    *ptr = 0;
    return 0;
  }

#ifdef SWIG_COBJECT_TYPES
  if (!(PySwigObject_Check(obj))) {
    if (!SWIG_this)
      SWIG_this = PyString_FromString("this");
    pyobj = obj;
    obj = PyObject_GetAttr(obj,SWIG_this);
    newref = 1;
    if (!obj) goto type_error;
    if (!PySwigObject_Check(obj)) {
      Py_DECREF(obj);
      goto type_error;
    }
  }  
  vptr = PySwigObject_AsVoidPtr(obj);
  c = (const char *) PySwigObject_GetDesc(obj);
  if (newref) { Py_DECREF(obj); }
  goto type_check;
#else
  if (!(PyString_Check(obj))) {
    if (!SWIG_this)
      SWIG_this = PyString_FromString("this");
    pyobj = obj;
    obj = PyObject_GetAttr(obj,SWIG_this);
    newref = 1;
    if (!obj) goto type_error;
    if (!PyString_Check(obj)) {
      Py_DECREF(obj);
      goto type_error;
    }
  } 
  c = PyString_AS_STRING(obj);
  /* Pointer values must start with leading underscore */
  c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
  if (newref) { Py_DECREF(obj); }
  if (!c) goto type_error;
#endif

type_check:

  if (ty) {
    tc = SWIG_TypeCheck(c,ty);
    if (!tc) goto type_error;
    *ptr = SWIG_TypeCast(tc,vptr);
  } else {
    *ptr = vptr;
  }

  if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
    PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
  }
  return 0;

type_error:
  PyErr_Clear();
  if (pyobj && !obj) {    
    obj = pyobj;
    if (PyCFunction_Check(obj)) {
      /* here we get the method pointer for callbacks */
      char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
      c = doc ? strstr(doc, "swig_ptr: ") : 0;
      if (c) {
	c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
	if (!c) goto type_error;
	goto type_check;
      }
    }
  }
  if (flags & SWIG_POINTER_EXCEPTION) {
    if (ty) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
    } else {
      SWIG_Python_TypeError("C/C++ pointer", obj);
    }
  }
  return -1;
}

/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
  void *result;
  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
    PyErr_Clear();
    if (flags & SWIG_POINTER_EXCEPTION) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
      SWIG_Python_ArgFail(argnum);
    }
  }
  return result;
}

/* Convert a packed value value */
SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
  swig_type_info *tc;
  const char *c = 0;

#if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
  c = PySwigPacked_UnpackData(obj, ptr, sz);
#else
  if ((!obj) || (!PyString_Check(obj))) goto type_error;
  c = PyString_AS_STRING(obj);
  /* Pointer values must start with leading underscore */
  c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
#endif
  if (!c) goto type_error;
  if (ty) {
    tc = SWIG_TypeCheck(c,ty);
    if (!tc) goto type_error;
  }
  return 0;

type_error:
  PyErr_Clear();
  if (flags & SWIG_POINTER_EXCEPTION) {
    if (ty) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
    } else {
      SWIG_Python_TypeError("C/C++ packed data", obj);
    }
  }
  return -1;
}  

/* Create a new array object */
SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
  PyObject *robj = 0;
  if (!ptr) {
    Py_INCREF(Py_None);
    return Py_None;
  }
#ifdef SWIG_COBJECT_TYPES
  robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
#else
  {
    char result[SWIG_BUFFER_SIZE];
    robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
      PyString_FromString(result) : 0;
  }
#endif
  if (!robj || (robj == Py_None)) return robj;
  if (type->clientdata) {
    PyObject *inst;
    PyObject *args = Py_BuildValue((char*)"(O)", robj);
    Py_DECREF(robj);
    inst = PyObject_CallObject((PyObject *) type->clientdata, args);
    Py_DECREF(args);
    if (inst) {
      if (own) {
        PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
      }
      robj = inst;
    }
  }
  return robj;
}

SWIGRUNTIME PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
  PyObject *robj = 0;
  if (!ptr) {
    Py_INCREF(Py_None);
    return Py_None;
  }
#if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
  robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
#else
  {
    char result[SWIG_BUFFER_SIZE];
    robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
      PyString_FromString(result) : 0;
  }
#endif
  return robj;
}

/* -----------------------------------------------------------------------------*
 *  Get type list 
 * -----------------------------------------------------------------------------*/

#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif

SWIGRUNTIME swig_type_info **
SWIG_Python_GetTypeListHandle() {
  static void *type_pointer = (void *)0;
  /* first check if module already created */
  if (!type_pointer) {
#ifdef SWIG_LINK_RUNTIME
    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
#else
    type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
				    (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
    if (PyErr_Occurred()) {
      PyErr_Clear();
      type_pointer = (void *)0;
    }
  }
#endif
  return (swig_type_info **) type_pointer;
}

/*
  Search for a swig_type_info structure
 */
SWIGRUNTIMEINLINE swig_type_info *
SWIG_Python_GetTypeList() {
  swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
  return tlh ? *tlh : (swig_type_info*)0;
}

#define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList 

#ifdef __cplusplus
}
#endif


/* -------- TYPES TABLE (BEGIN) -------- */

#define  SWIGTYPE_p_iCollider swig_types[0] 
#define  SWIGTYPE_p_f_p_iMeshWrapper_p_iFrustumView_bool__void swig_types[1] 
#define  SWIGTYPE_p_iObjectRegistry swig_types[2] 
#define  SWIGTYPE_p_iDocumentNode swig_types[3] 
#define  SWIGTYPE_p_iPcMovableConstraint swig_types[4] 
#define  SWIGTYPE_p_iCelPropertyClassList swig_types[5] 
#define  SWIGTYPE_p_celPersistenceType swig_types[6] 
#define  SWIGTYPE_p_celInitializer swig_types[7] 
#define  SWIGTYPE_p_csInitializer swig_types[8] 
#define  SWIGTYPE_std__size_t swig_types[9] 
#define  SWIGTYPE_size_t swig_types[10] 
#define  SWIGTYPE_p_iPcDefaultCamera swig_types[11] 
#define  SWIGTYPE_p_iCelPropertyClassFactory swig_types[12] 
#define  SWIGTYPE_p_iSector swig_types[13] 
#define  SWIGTYPE_p_p_iSector swig_types[14] 
#define  SWIGTYPE_p_csArrayTcsImageIOFileFormatDescription_const_p_csArrayElementHandlerTcsImageIOFileFormatDescription_const_p_t_csArrayMemoryAllocatorTcsImageIOFileFormatDescription_const_p_t_t swig_types[15] 
#define  SWIGTYPE_p_iCelParameterBlock swig_types[16] 
#define  SWIGTYPE_p_csPtrTiCelEntityList_t swig_types[17] 
#define  SWIGTYPE_p_bool swig_types[18] 
#define  SWIGTYPE_p_iPcCharacteristics swig_types[19] 
#define  SWIGTYPE_p__csKeyModifierType swig_types[20] 
#define  SWIGTYPE_p_int8_t swig_types[21] 
#define  SWIGTYPE_p_uint8_t swig_types[22] 
#define  SWIGTYPE_p__csKeyEventType swig_types[23] 
#define  SWIGTYPE_p__csMouseEventType swig_types[24] 
#define  SWIGTYPE_p_csPtrTiCelMessage_t swig_types[25] 
#define  SWIGTYPE_p__csKeyCharType swig_types[26] 
#define  SWIGTYPE_p_iPcMeshSelect swig_types[27] 
#define  SWIGTYPE_p__csKeyModifiers swig_types[28] 
#define  SWIGTYPE_p_iPcTooltip swig_types[29] 
#define  SWIGTYPE_p_iCelEntityTracker swig_types[30] 
#define  SWIGTYPE_p_csColor swig_types[31] 
#define  SWIGTYPE_p_int32_t swig_types[32] 
#define  SWIGTYPE_p_uint32_t swig_types[33] 
#define  SWIGTYPE_p_iCelEntity swig_types[34] 
#define  SWIGTYPE_p_iCelRegion swig_types[35] 
#define  SWIGTYPE_p_void swig_types[36] 
#define  SWIGTYPE_p_iPcLight swig_types[37] 
#define  SWIGTYPE_p_int swig_types[38] 
#define  SWIGTYPE_p_csPtrTiCelDataBuffer_t swig_types[39] 
#define  SWIGTYPE_p_iCelMapFile swig_types[40] 
#define  SWIGTYPE_p_iPath swig_types[41] 
#define  SWIGTYPE_p_iJoint swig_types[42] 
#define  SWIGTYPE_p_iCelEntityList swig_types[43] 
#define  SWIGTYPE_p_celData swig_types[44] 
#define  SWIGTYPE_p_iObject swig_types[45] 
#define  SWIGTYPE_p_iPcMechanicsObject swig_types[46] 
#define  SWIGTYPE_p_csHashTcsStrKey_csStrKey_t swig_types[47] 
#define  SWIGTYPE_p_iBillboard swig_types[48] 
#define  SWIGTYPE_p_iPcBillboard swig_types[49] 
#define  SWIGTYPE_p_iPcLinearMovement swig_types[50] 
#define  SWIGTYPE_p_iSndSysSource swig_types[51] 
#define  SWIGTYPE_p_csString swig_types[52] 
#define  SWIGTYPE_p_iString swig_types[53] 
#define  SWIGTYPE_p_iCelEntityTemplate swig_types[54] 
#define  SWIGTYPE_p_iAwsComponent swig_types[55] 
#define  SWIGTYPE_p_csDirtyAccessArrayTcsSprite2DVertex_t swig_types[56] 
#define  SWIGTYPE_p_csFlags swig_types[57] 
#define  SWIGTYPE_p_iPcCommandInput swig_types[58] 
#define  SWIGTYPE_p_csOrthoTransform swig_types[59] 
#define  SWIGTYPE_p_iCelPropertyClass swig_types[60] 
#define  SWIGTYPE_p_iStringArray swig_types[61] 
#define  SWIGTYPE_p_iPcMovable swig_types[62] 
#define  SWIGTYPE_p_iBillboardEventHandler swig_types[63] 
#define  SWIGTYPE_p_iPcCollisionDetection swig_types[64] 
#define  SWIGTYPE_p_p_iPcCollisionDetection swig_types[65] 
#define  SWIGTYPE_int swig_types[66] 
#define  SWIGTYPE_p__csKeyModifierNumType swig_types[67] 
#define  SWIGTYPE_p_int16_t swig_types[68] 
#define  SWIGTYPE_p_uint16_t swig_types[69] 
#define  SWIGTYPE_p_uint64_t swig_types[70] 
#define  SWIGTYPE_p_int64_t swig_types[71] 
#define  SWIGTYPE_p_iPcActorMove swig_types[72] 
#define  SWIGTYPE_p_char swig_types[73] 
#define  SWIGTYPE_p_FileFormatDescription swig_types[74] 
#define  SWIGTYPE_p_iMeshWrapper swig_types[75] 
#define  SWIGTYPE_p_iFont swig_types[76] 
#define  SWIGTYPE_p_iCelPropertyChangeCallback swig_types[77] 
#define  SWIGTYPE_p_iCelEntityRemoveCallback swig_types[78] 
#define  SWIGTYPE_p_iCelNewEntityCallback swig_types[79] 
#define  SWIGTYPE_p_iPcMechanicsBalancedGroup swig_types[80] 
#define  SWIGTYPE_p_iPcGravityCallback swig_types[81] 
#define  SWIGTYPE_p_iBillboardManager swig_types[82] 
#define  SWIGTYPE_p_iPcZoneManager swig_types[83] 
#define  SWIGTYPE_p_csArrayTcsPluginRequest_csArrayElementHandlerTcsPluginRequest_t_csArrayMemoryAllocatorTcsPluginRequest_t_t swig_types[84] 
#define  SWIGTYPE_p_iCamera swig_types[85] 
#define  SWIGTYPE_p_iPcCamera swig_types[86] 
#define  SWIGTYPE_p_iPcMesh swig_types[87] 
#define  SWIGTYPE_p_iPcSimpleCamera swig_types[88] 
#define  SWIGTYPE_p_csArrayTcsShaderVariable_p_csArrayElementHandlerTcsShaderVariable_p_t_csArrayMemoryAllocatorTcsShaderVariable_p_t_t swig_types[89] 
#define  SWIGTYPE_p_iCelBehaviour swig_types[90] 
#define  SWIGTYPE_p_csPtrTiRigidBody_t swig_types[91] 
#define  SWIGTYPE_p_iBillboardLayer swig_types[92] 
#define  SWIGTYPE_p_iCelZone swig_types[93] 
#define  SWIGTYPE_p_iPcTimer swig_types[94] 
#define  SWIGTYPE_p_iPcSoundSource swig_types[95] 
#define  SWIGTYPE_p_csVector2 swig_types[96] 
#define  SWIGTYPE_p_csPlane3 swig_types[97] 
#define  SWIGTYPE_p_unsigned_long swig_types[98] 
#define  SWIGTYPE_p_iCelDataBuffer swig_types[99] 
#define  SWIGTYPE_p_csVector3 swig_types[100] 
#define  SWIGTYPE_p_celPersistenceResult swig_types[101] 
#define  SWIGTYPE_p_iPcMechanicsThruster swig_types[102] 
#define  SWIGTYPE_p_iPcGravity swig_types[103] 
#define  SWIGTYPE_p_iRigidBody swig_types[104] 
#define  SWIGTYPE_p_int_least64_t swig_types[105] 
#define  SWIGTYPE_p_uint_least64_t swig_types[106] 
#define  SWIGTYPE_p_iDynamicSystem swig_types[107] 
#define  SWIGTYPE_p_iPcMechanicsSystem swig_types[108] 
#define  SWIGTYPE_p_iPcMechanicsJoint swig_types[109] 
#define  SWIGTYPE_p_iCelInventorySpace swig_types[110] 
#define  SWIGTYPE_p_basetype swig_types[111] 
#define  SWIGTYPE_p_csRefArrayTiObject_t swig_types[112] 
#define  SWIGTYPE_p_iPcSolid swig_types[113] 
#define  SWIGTYPE_p_unsigned_int swig_types[114] 
#define  SWIGTYPE_p_csBox3 swig_types[115] 
#define  SWIGTYPE_p_iView swig_types[116] 
#define  SWIGTYPE_p_iCelInventorySpaceSlot swig_types[117] 
#define  SWIGTYPE_p_csPtrTiCelEntity_t swig_types[118] 
#define  SWIGTYPE_p_iCelTimerListener swig_types[119] 
#define  SWIGTYPE_p_iPcMeshSelectListener swig_types[120] 
#define  SWIGTYPE_p_iPcInventoryListener swig_types[121] 
#define  SWIGTYPE_p_iPcSoundListener swig_types[122] 
#define  SWIGTYPE_p_iSndSysListener swig_types[123] 
#define  SWIGTYPE_p_celDataType swig_types[124] 
#define  SWIGTYPE_p__csMouseCursorID swig_types[125] 
#define  SWIGTYPE_p_iPcMechanicsThrusterController swig_types[126] 
#define  SWIGTYPE_p_float swig_types[127] 
#define  SWIGTYPE_p_iBase swig_types[128] 
#define  SWIGTYPE_p_iCelBlLayer swig_types[129] 
#define  SWIGTYPE_p_iCelPlLayer swig_types[130] 
#define  SWIGTYPE_p_iPcInventory swig_types[131] 
#define  SWIGTYPE_p_iPcRegion swig_types[132] 
#define  SWIGTYPE_p_iRegion swig_types[133] 
static swig_type_info *swig_types[135];

/* -------- TYPES TABLE (END) -------- */


/*-----------------------------------------------
              @(target):= _blcelc.so
  ------------------------------------------------*/
#define SWIG_init SWIG_init_blcelc

#define SWIG_name    "_blcelc"

#include <crystalspace.h>
#include "celtool/initapp.h"
#include "physicallayer/pl.h"
#include "physicallayer/propfact.h"
#include "physicallayer/propclas.h"
#include "physicallayer/entity.h"
#include "physicallayer/persist.h"
#include "behaviourlayer/bl.h"
#include "behaviourlayer/behave.h"
#include "propclass/region.h"
#include "propclass/camera.h"
#include "propclass/defcam.h"
#include "propclass/simpcam.h"
#include "propclass/mesh.h"
#include "propclass/meshsel.h"
#include "propclass/timer.h"
#include "propclass/solid.h"
#include "propclass/gravity.h"
#include "propclass/move.h"
#include "propclass/inv.h"
#include "propclass/chars.h"
#include "propclass/linmove.h"
#include "propclass/actormove.h"
#include "propclass/input.h"
#include "propclass/billboard.h"
#include "propclass/mechsys.h"
#include "propclass/sound.h"
#include "propclass/mechthruster.h"
#include "propclass/tooltip.h"
#include "plugins/behaviourlayer/python/blpython.h"
#include "tools/billboard.h"
#include "propclass/zone.h"



  struct _csPyEventHandler : public iEventHandler
  {
    SCF_DECLARE_IBASE;
    _csPyEventHandler (PyObject * obj) : _pySelf(obj)
    {
      SCF_CONSTRUCT_IBASE(0);
      IncRef();
    }
    virtual ~_csPyEventHandler ()
    {
      SCF_DESTRUCT_IBASE();
      DecRef();
    }
    virtual bool HandleEvent (iEvent & event)
    {
      PyObject * event_obj = SWIG_NewPointerObj(
        (void *) &event, SWIG_TypeQuery("iEvent *"), 0
      );
      PyObject * result = PyObject_CallMethod(_pySelf, "HandleEvent", "(O)",
        event_obj
      );
      Py_DECREF(event_obj);
      if (!result)
      {
        return false;
      }
      bool res = PyInt_AsLong(result);
      Py_DECREF(result);
      return res;
    }
  private:
    PyObject * _pySelf;
  };



SWIGINTERNSHORT PyObject*
  SWIG_From_bool(bool value)
{
  PyObject *obj = value ? Py_True : Py_False;
  Py_INCREF(obj);
  return obj;
}


  /*@/usr/share/swig1.3/python/pymacros.swg,66,SWIG_define@*/
#define SWIG_From_int PyInt_FromLong
/*@@*/


#include <limits.h>


SWIGINTERN int
  SWIG_CheckLongInRange(long value, long min_value, long max_value,
			const char *errmsg)
{
  if (value < min_value) {
    if (errmsg) {
      PyErr_Format(PyExc_OverflowError, 
		   "value %ld is less than '%s' minimum %ld", 
		   value, errmsg, min_value);
    }
    return 0;    
  } else if (value > max_value) {
    if (errmsg) {
      PyErr_Format(PyExc_OverflowError,
		   "value %ld is greater than '%s' maximum %ld", 
		   value, errmsg, max_value);
    }
    return 0;
  }
  return 1;
}


SWIGINTERN int
  SWIG_AsVal_long(PyObject * obj, long* val)
{
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AS_LONG(obj);
    return 1;
  }
  if (PyLong_Check(obj)) {
    long v = PyLong_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return 1;
    } else {
      if (!val) PyErr_Clear();
      return 0;
    }
  }
  if (val) {
    SWIG_type_error("long", obj);
  }
  return 0;
 }


#if INT_MAX != LONG_MAX
SWIGINTERN int
  SWIG_AsVal_int(PyObject *obj, int *val)
{ 
  const char* errmsg = val ? "int" : (char*)0;
  long v;
  if (SWIG_AsVal_long(obj, &v)) {
    if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
      if (val) *val = (int)(v);
      return 1;
    } else {
      return 0;
    }
  } else {
    PyErr_Clear();
  }
  if (val) {
    SWIG_type_error(errmsg, obj);
  }
  return 0;    
}
#else
SWIGINTERNSHORT int
  SWIG_AsVal_int(PyObject *obj, int *val)
{
  return SWIG_AsVal_long(obj,(long*)val);
}
#endif


SWIGINTERNSHORT int
SWIG_As_int(PyObject* obj)
{
  int v;
  if (!SWIG_AsVal_int(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(int));
  }
  return v;
}

  
SWIGINTERNSHORT int
SWIG_Check_int(PyObject* obj)
{
  return SWIG_AsVal_int(obj, (int*)0);
}


SWIGINTERNSHORT int
  SWIG_CheckUnsignedLongInRange(unsigned long value,
				unsigned long max_value,
				const char *errmsg) 
{
  if (value > max_value) {
    if (errmsg) {
      PyErr_Format(PyExc_OverflowError,
		   "value %lu is greater than '%s' minimum %lu",
		   value, errmsg, max_value);
    }
    return 0;
  }
  return 1;
 }


SWIGINTERN int
  SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val) 
{
  if (PyInt_Check(obj)) {
    long v = PyInt_AS_LONG(obj);
    if (v >= 0) {
      if (val) *val = v;
      return 1;
    }   
  }
  if (PyLong_Check(obj)) {
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return 1;
    } else {
      if (!val) PyErr_Clear();
      return 0;
    }
  } 
  if (val) {
    SWIG_type_error("unsigned long", obj);
  }
  return 0;
}


#if UINT_MAX != ULONG_MAX
SWIGINTERN int
  SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
{ 
  const char* errmsg = val ? "unsigned int" : (char*)0;
  unsigned long v;
  if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
    if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
      if (val) *val = (unsigned int)(v);
      return 1;
    }
  } else {
    PyErr_Clear();
  }
  if (val) {
    SWIG_type_error(errmsg, obj);
  }
  return 0;    
}
#else
SWIGINTERNSHORT unsigned int
  SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
{
  return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
}
#endif


SWIGINTERNSHORT unsigned int
SWIG_As_unsigned_SS_int(PyObject* obj)
{
  unsigned int v;
  if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(unsigned int));
  }
  return v;
}

  
SWIGINTERNSHORT int
SWIG_Check_unsigned_SS_int(PyObject* obj)
{
  return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
}


/* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
{
  static swig_type_info* pchar_info = 0;
  char* vptr = 0;
  if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
  if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
    if (cptr) *cptr = vptr;
    if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
    return SWIG_OLDOBJ;
  } else {
    PyErr_Clear();
    if (PyString_Check(obj)) {
      if (cptr) {
	*cptr = PyString_AS_STRING(obj);
	if (psize) {
	  *psize = PyString_GET_SIZE(obj) + 1;
	}
      }
      return SWIG_PYSTR;
    }
  }
  if (cptr) {
    SWIG_type_error("char *", obj);
  }
  return 0;
}


SWIGINTERNSHORT int
SWIG_AsCharPtr(PyObject *obj, char **val)
{
  if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
    return 1;
  }
  if (val) {
    PyErr_Clear();
    SWIG_type_error("char *", obj);
  }
  return 0;
}


SWIGINTERNSHORT long
SWIG_As_long(PyObject* obj)
{
  long v;
  if (!SWIG_AsVal_long(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(long));
  }
  return v;
}

  
SWIGINTERNSHORT int
SWIG_Check_long(PyObject* obj)
{
  return SWIG_AsVal_long(obj, (long*)0);
}


SWIGINTERNSHORT PyObject* 
  SWIG_From_unsigned_SS_long(unsigned long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLong(value) 
    : PyInt_FromLong((long)(value)); 
}


SWIGINTERNSHORT unsigned long
SWIG_As_unsigned_SS_long(PyObject* obj)
{
  unsigned long v;
  if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(unsigned long));
  }
  return v;
}

  
SWIGINTERNSHORT int
SWIG_Check_unsigned_SS_long(PyObject* obj)
{
  return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
}


#include <float.h>
SWIGINTERN int
  SWIG_CheckDoubleInRange(double value, double min_value, 
			  double max_value, const char* errmsg)
{
  if (value < min_value) {
    if (errmsg) {
      PyErr_Format(PyExc_OverflowError, 
		   "value %g is less than %s minimum %g", 
		   value, errmsg, min_value);
    }
    return 0;
  } else if (value > max_value) {
    if (errmsg) {
      PyErr_Format(PyExc_OverflowError, 
		   "value %g is greater than %s maximum %g", 
		   value, errmsg, max_value);
    }
    return 0;
  }
  return 1;
}


SWIGINTERN int
  SWIG_AsVal_double(PyObject *obj, double *val)
{
  if (PyFloat_Check(obj)) {
    if (val) *val = PyFloat_AS_DOUBLE(obj);
    return 1;
  }  
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AS_LONG(obj);
    return 1;
  }
  if (PyLong_Check(obj)) {
    double v = PyLong_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return 1;
    } else {
      if (!val) PyErr_Clear();
      return 0;
    }
  }
  if (val) {
    SWIG_type_error("double", obj);
  }
  return 0;
}


SWIGINTERN int
  SWIG_AsVal_float(PyObject *obj, float *val)
{
  const char* errmsg = val ? "float" : (char*)0;
  double v;
  if (SWIG_AsVal_double(obj, &v)) {
    if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
      if (val) *val = (float)(v);
      return 1;
    } else {
      return 0;
    }
  } else {
    PyErr_Clear();
  }
  if (val) {
    SWIG_type_error(errmsg, obj);
  }
  return 0;
}


SWIGINTERNSHORT float
SWIG_As_float(PyObject* obj)
{
  float v;
  if (!SWIG_AsVal_float(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(float));
  }
  return v;
}

  
SWIGINTERNSHORT int
SWIG_Check_float(PyObject* obj)
{
  return SWIG_AsVal_float(obj, (float*)0);
}


SWIGINTERN int
  SWIG_AsVal_bool(PyObject *obj, bool *val)
{
  if (obj == Py_True) {
    if (val) *val = true;
    return 1;
  }
  if (obj == Py_False) {
    if (val) *val = false;
    return 1;
  }
  int res = 0;
  if (SWIG_AsVal_int(obj, &res)) {    
    if (val) *val = res ? true : false;
    return 1;
  } else {
    PyErr_Clear();
  }  
  if (val) {
    SWIG_type_error("bool", obj);
  }
  return 0;
}


SWIGINTERNSHORT bool
SWIG_As_bool(PyObject* obj)
{
  bool v;
  if (!SWIG_AsVal_bool(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(bool));
  }
  return v;
}

  
SWIGINTERNSHORT int
SWIG_Check_bool(PyObject* obj)
{
  return SWIG_AsVal_bool(obj, (bool*)0);
}


SWIGINTERN PyObject *
SWIG_FromCharPtr(const char* cptr)
{ 
  if (cptr) {
    size_t size = strlen(cptr);
    if (size > INT_MAX) {
      return SWIG_NewPointerObj((char*)(cptr), 
				SWIG_TypeQuery("char *"), 0);
    } else {
      if (size != 0) {
	return PyString_FromStringAndSize(cptr, size);
      } else {
	return PyString_FromString(cptr);
      }
    }
  }
  Py_INCREF(Py_None);
  return Py_None;
}


iCelPlLayer *csQueryRegistry_iCelPlLayer (iObjectRegistry *object_reg)
{
  csRef<iCelPlLayer> pl = CS_QUERY_REGISTRY (object_reg, iCelPlLayer);
  return pl;
}


  /*@/usr/share/swig1.3/python/pymacros.swg,66,SWIG_define@*/
#define SWIG_From_long PyInt_FromLong
/*@@*/


#if UINT_MAX < LONG_MAX
/*@/usr/share/swig1.3/python/pymacros.swg,66,SWIG_define@*/
#define SWIG_From_unsigned_SS_int SWIG_From_long
/*@@*/
#else
/*@/usr/share/swig1.3/python/pymacros.swg,66,SWIG_define@*/
#define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
/*@@*/
#endif

static iCelBehaviour *iCelEntity_CreateBehaviour(iCelEntity *self,iCelBlLayer *bl,char const *name){
    csRef<iCelBehaviour> bh(bl->CreateBehaviour(self, name));
    if (!bh.IsValid()) return 0;
    return bh;
  }

bool celRegisterPCFactory (iObjectRegistry* object_reg, const char* pcfactname)
{
  csRef<iCelPlLayer> pl = CS_QUERY_REGISTRY (object_reg,
  	iCelPlLayer);
  bool rc = pl->LoadPropertyClassFactory (pcfactname);
  return rc;
}


iCelEntity *celCreateEntity(iCelPlLayer *pl, const char *name)
{
  csRef<iCelEntity> en = pl->CreateEntity();
  if (!en.IsValid()) return 0;
  en->SetName (name);
  en->IncRef ();
  return en;
}


iCelEntity *scfQueryInterface_iCelEntity (iBase *base)
{
  csRef<iCelEntity> ent = SCF_QUERY_INTERFACE (base, iCelEntity);
  return ent;
}


iCelEntityList *celFindNearbyEntities (iObjectRegistry *object_reg,
	iSector *sector, csVector3 pos, float radius)
{
  csRef<iCelPlLayer> pl = CS_QUERY_REGISTRY (object_reg, iCelPlLayer);
  if (!pl.IsValid()) return 0;
  csRef<iCelEntityList> entlist = pl->FindNearbyEntities (sector, pos, radius);
  entlist->IncRef();
  return entlist;
}


iCelBlLayer *csQueryRegistry_iCelBlLayer (iObjectRegistry *object_reg)
{
  csRef<iCelBlLayer> bl = CS_QUERY_REGISTRY (object_reg, iCelBlLayer);
  return bl;
}

static PyObject *iCelParameterBlock_GetParameterValue(iCelParameterBlock *self,csStringID id){
		const celData *data = self->GetParameter(id);
		PyObject *obj = Py_None;
		if (data)
		{
		    switch(data->type)
		    {
			case CEL_DATA_FLOAT:
				obj = PyFloat_FromDouble((float)data->value.f);
				break;
			case CEL_DATA_BOOL:
				obj = SWIG_From_bool((bool)data->value.bo);
				break;
			case CEL_DATA_STRING:
			{
				char *result;
				result = (char*)((iString const *)(data->value.s)->GetData());
				obj = SWIG_FromCharPtr(result);
				break;
			}
			case CEL_DATA_VECTOR2:
			{
				csVector2 *result;
				result = new csVector2(data->value.v.x,data->value.v.y);
				obj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_csVector2, 1);
				break;
			}
			case CEL_DATA_VECTOR3:
			{
				csVector3 *result;
				result = new csVector3(data->value.v.x,data->value.v.y,data->value.v.z);
				obj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_csVector3, 1);
				break;
			}
			case CEL_DATA_ENTITY:
			{
				iCelEntity *result;
				result = (iCelEntity *)(data->value.ent);
				obj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntity, 0);
				break;
			}
			case CEL_DATA_PCLASS:
			{
				iCelPropertyClass *result;
				result = (iCelPropertyClass *)(data->value.pc);
				obj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelPropertyClass, 0);
				break;
			}
			case CEL_DATA_ACTION:
			{
				char *result;
				result = (char*)((iString const *)(data->value.s)->GetData());
				obj = SWIG_FromCharPtr(result);
				break;
			}
			case CEL_DATA_IBASE:
			{
				iBase *result;
				result = (iBase *)(data->value.pc);
				obj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iBase, 0);
				break;
			}
			case CEL_DATA_COLOR:
			{
				csColor *result;
				result = new csColor(data->value.col.red,data->value.col.green,data->value.col.blue);
				obj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_csColor, 1);
				break;
			}
			case CEL_DATA_WORD:
			{
				obj = SWIG_From_int((int)data->value.w);
				break;
			}
			case CEL_DATA_LONG:
			{
				obj = SWIG_From_long((long)data->value.l);
				break;
			}
			case CEL_DATA_ULONG:
			{
				obj = PyLong_FromUnsignedLong((unsigned long)data->value.ul);
				break;
			}
			{
				break;
			}
			/* Still to be done (and some more) */
			case CEL_DATA_BYTE:
				/*data->value.b (int8)*/
			case CEL_DATA_UWORD:
				/*data->value.uw (uint16)*/
			case CEL_DATA_PARAMETER:
				/*data->value.par (iString+celDataType)*/
			default:
				obj = Py_None;
				break;
		    }
		}
		return obj;
	}
static PyObject *iCelBehaviour_GetPythonObject(iCelBehaviour *self){
    PyObject* obj = (PyObject*)(self->GetInternalObject());
    Py_INCREF (obj);
    return obj;
  }

  /*@/usr/share/swig1.3/python/pymacros.swg,66,SWIG_define@*/
#define SWIG_From_float PyFloat_FromDouble
/*@@*/

static bool iCelPropertyClass_SetPropertyLong(iCelPropertyClass *self,csStringID id,long l){ return self->SetProperty (id, l); }
static bool iCelPropertyClass_SetPropertyFloat(iCelPropertyClass *self,csStringID id,float f){ return self->SetProperty (id, f); }
static bool iCelPropertyClass_SetPropertyBool(iCelPropertyClass *self,csStringID id,bool b){ return self->SetProperty (id, b); }
static bool iCelPropertyClass_SetPropertyString(iCelPropertyClass *self,csStringID id,char const *s){ return self->SetProperty (id, s); }
static bool iCelPropertyClass_SetPropertyVector3(iCelPropertyClass *self,csStringID id,csVector3 const &v){ return self->SetProperty (id, v); }

iPcMechanicsSystem *celCreateMechanicsSystem(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pcmechsys" );
  if (!pc.IsValid()) return 0;
  csRef<iPcMechanicsSystem> pclm =    scfQueryInterface<iPcMechanicsSystem> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcMechanicsSystem * celGetMechanicsSystem (iCelEntity *entity)
{
  csRef<iPcMechanicsSystem> pc =    (celQueryPropertyClass<iPcMechanicsSystem> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcMechanicsSystem *scfQuery_iPcMechanicsSystem (iCelPropertyClass *pc)
{
  csRef<iPcMechanicsSystem> iface =    scfQueryInterface<iPcMechanicsSystem> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcMechanicsSystem *scfQueryPC_iPcMechanicsSystem (iCelPropertyClassList *pclist)
{
  csRef<iPcMechanicsSystem> iface =    scfQueryInterface<iPcMechanicsSystem> (pclist);
  if (iface) iface->IncRef ();
  return iface;
}


iPcMechanicsObject *celCreateMechanicsObject(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pcmechobject" );
  if (!pc.IsValid()) return 0;
  csRef<iPcMechanicsObject> pclm =    scfQueryInterface<iPcMechanicsObject> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcMechanicsObject * celGetMechanicsObject (iCelEntity *entity)
{
  csRef<iPcMechanicsObject> pc =    (celQueryPropertyClass<iPcMechanicsObject> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcMechanicsObject *scfQuery_iPcMechanicsObject (iCelPropertyClass *pc)
{
  csRef<iPcMechanicsObject> iface =    scfQueryInterface<iPcMechanicsObject> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcMechanicsObject *scfQueryPC_iPcMechanicsObject (iCelPropertyClassList *pclist)
{
  csRef<iPcMechanicsObject> iface =    scfQueryInterface<iPcMechanicsObject> (pclist);
  if (iface) iface->IncRef ();
  return iface;
}


iPcMechanicsThruster *celCreateMechanicsThrusterReactionary(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pcmechthrustreactionary" );
  if (!pc.IsValid()) return 0;
  csRef<iPcMechanicsThruster> pclm =    scfQueryInterface<iPcMechanicsThruster> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcMechanicsThruster * celGetMechanicsThrusterReactionary (iCelEntity *entity)
{
  csRef<iPcMechanicsThruster> pc =    (celQueryPropertyClass<iPcMechanicsThruster> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcMechanicsThruster *scfQuery_iPcMechanicsThruster (iCelPropertyClass *pc)
{
  csRef<iPcMechanicsThruster> iface =    scfQueryInterface<iPcMechanicsThruster> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcMechanicsThruster *scfQueryPC_iPcMechanicsThruster (iCelPropertyClassList *pclist)
{
  csRef<iPcMechanicsThruster> iface =    scfQueryInterface<iPcMechanicsThruster> (pclist);
  if (iface) iface->IncRef ();
  return iface;
}


iPcMechanicsBalancedGroup *celCreateMechanicsBalancedGroup(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pcmechbalancedgroup" );
  if (!pc.IsValid()) return 0;
  csRef<iPcMechanicsBalancedGroup> pclm =    scfQueryInterface<iPcMechanicsBalancedGroup> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcMechanicsBalancedGroup * celGetMechanicsBalancedGroup (iCelEntity *entity)
{
  csRef<iPcMechanicsBalancedGroup> pc =    (celQueryPropertyClass<iPcMechanicsBalancedGroup> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcMechanicsBalancedGroup *scfQuery_iPcMechanicsBalancedGroup (iCelPropertyClass *pc)
{
  csRef<iPcMechanicsBalancedGroup> iface =    scfQueryInterface<iPcMechanicsBalancedGroup> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcMechanicsBalancedGroup *scfQueryPC_iPcMechanicsBalancedGroup (iCelPropertyClassList *pclist)
{
  csRef<iPcMechanicsBalancedGroup> iface =    scfQueryInterface<iPcMechanicsBalancedGroup> (pclist);
  if (iface) iface->IncRef ();
  return iface;
}


iPcMechanicsThrusterController *celCreateMechanicsThrusterController(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pcmechthrustercontroller" );
  if (!pc.IsValid()) return 0;
  csRef<iPcMechanicsThrusterController> pclm =    scfQueryInterface<iPcMechanicsThrusterController> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcMechanicsThrusterController * celGetMechanicsThrusterController (iCelEntity *entity)
{
  csRef<iPcMechanicsThrusterController> pc =    (celQueryPropertyClass<iPcMechanicsThrusterController> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcMechanicsThrusterController *scfQuery_iPcMechanicsThrusterController (iCelPropertyClass *pc)
{
  csRef<iPcMechanicsThrusterController> iface =    scfQueryInterface<iPcMechanicsThrusterController> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcMechanicsThrusterController *scfQueryPC_iPcMechanicsThrusterController (iCelPropertyClassList *pclist)
{
  csRef<iPcMechanicsThrusterController> iface =    scfQueryInterface<iPcMechanicsThrusterController> (pclist);
  if (iface) iface->IncRef ();
  return iface;
}


SWIGINTERN PyObject*
t_output_helper(PyObject* target, PyObject* o) {
  if (!target) {
    target = o;
  } else if (target == Py_None) {  
    Py_DECREF(target);
    target = o;
  } else {
    if (!PyList_Check(target)) {
      PyObject *o2 = target;
      target = PyList_New(1);
      PyList_SetItem(target, 0, o2);
    }
    PyList_Append(target,o);
    }
  return target;
}



iPcBillboard *celCreateBillboard(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pcbillboard" );
  if (!pc.IsValid()) return 0;
  csRef<iPcBillboard> pclm =    scfQueryInterface<iPcBillboard> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcBillboard * celGetBillboard (iCelEntity *entity)
{
  csRef<iPcBillboard> pc =    (celQueryPropertyClass<iPcBillboard> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcBillboard *scfQuery_iPcBillboard (iCelPropertyClass *pc)
{
  csRef<iPcBillboard> iface =    scfQueryInterface<iPcBillboard> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcBillboard *scfQueryPC_iPcBillboard (iCelPropertyClassList *pclist)
{
  csRef<iPcBillboard> iface =    scfQueryInterface<iPcBillboard> (pclist);
  if (iface) iface->IncRef ();
  return iface;
}

static bool iPcRegion_LoadWorld(iPcRegion *self,char const *vfsdir,char const *name){
    self->SetWorldFile (vfsdir, name);
    return self->Load ();
  }

iPcRegion *celCreateRegion (iCelPlLayer *pl, iCelEntity *entity,
	const char *name)
{
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity, "pcregion");
  if (!pc.IsValid()) return 0;
  csRef<iPcRegion> pcregion = SCF_QUERY_INTERFACE(pc, iPcRegion);
  if (!pcregion.IsValid()) return 0;
  pcregion->SetRegionName (name);
  return pcregion;
}


iPcRegion * Region (iCelEntity *entity)
{
  csRef<iPcRegion> pc =    (celQueryPropertyClass<iPcRegion> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcRegion *scfQuery_iPcRegion (iCelPropertyClass *pc)
{
  csRef<iPcRegion> iface =    scfQueryInterface<iPcRegion> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcRegion *scfQueryPC_iPcRegion (iCelPropertyClassList *pclist)
{
  csRef<iPcRegion> iface =    scfQueryInterface<iPcRegion> (pclist);
  if (iface) iface->IncRef ();
  return iface;
}


iPcZoneManager *celCreateZoneManager(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pczonemanager" );
  if (!pc.IsValid()) return 0;
  csRef<iPcZoneManager> pclm =    scfQueryInterface<iPcZoneManager> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcZoneManager * celGetZoneManager (iCelEntity *entity)
{
  csRef<iPcZoneManager> pc =    (celQueryPropertyClass<iPcZoneManager> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcZoneManager *scfQuery_iPcZoneManager (iCelPropertyClass *pc)
{
  csRef<iPcZoneManager> iface =    scfQueryInterface<iPcZoneManager> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcCommandInput *celCreateCommandInput(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pccommandinput" );
  if (!pc.IsValid()) return 0;
  csRef<iPcCommandInput> pclm =    scfQueryInterface<iPcCommandInput> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcCommandInput * celGetCommandInput (iCelEntity *entity)
{
  csRef<iPcCommandInput> pc =    (celQueryPropertyClass<iPcCommandInput> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcCommandInput *scfQuery_iPcCommandInput (iCelPropertyClass *pc)
{
  csRef<iPcCommandInput> iface =    scfQueryInterface<iPcCommandInput> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcLinearMovement *celCreateLinearMovement(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pclinearmovement" );
  if (!pc.IsValid()) return 0;
  csRef<iPcLinearMovement> pclm =    scfQueryInterface<iPcLinearMovement> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcLinearMovement * celGetLinearMovement (iCelEntity *entity)
{
  csRef<iPcLinearMovement> pc =    (celQueryPropertyClass<iPcLinearMovement> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcLinearMovement *scfQuery_iPcLinearMovement (iCelPropertyClass *pc)
{
  csRef<iPcLinearMovement> iface =    scfQueryInterface<iPcLinearMovement> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcActorMove *celCreateActorMove(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pcactormove" );
  if (!pc.IsValid()) return 0;
  csRef<iPcActorMove> pclm =    scfQueryInterface<iPcActorMove> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcActorMove * celGetActorMove (iCelEntity *entity)
{
  csRef<iPcActorMove> pc =    (celQueryPropertyClass<iPcActorMove> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcActorMove *scfQuery_iPcActorMove (iCelPropertyClass *pc)
{
  csRef<iPcActorMove> iface =    scfQueryInterface<iPcActorMove> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcCamera *celCreateCamera(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pccamera" );
  if (!pc.IsValid()) return 0;
  csRef<iPcCamera> pclm =    scfQueryInterface<iPcCamera> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcCamera * celGetCamera (iCelEntity *entity)
{
  csRef<iPcCamera> pc =    (celQueryPropertyClass<iPcCamera> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcCamera *scfQuery_iPcCamera (iCelPropertyClass *pc)
{
  csRef<iPcCamera> iface =    scfQueryInterface<iPcCamera> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcDefaultCamera *celCreateDefaultCamera(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pcdefaultcamera" );
  if (!pc.IsValid()) return 0;
  csRef<iPcDefaultCamera> pclm =    scfQueryInterface<iPcDefaultCamera> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcDefaultCamera * celGetDefaultCamera (iCelEntity *entity)
{
  csRef<iPcDefaultCamera> pc =    (celQueryPropertyClass<iPcDefaultCamera> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcDefaultCamera *scfQuery_iPcDefaultCamera (iCelPropertyClass *pc)
{
  csRef<iPcDefaultCamera> iface =    scfQueryInterface<iPcDefaultCamera> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcSimpleCamera *celCreateSimpleCamera(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pcsimplecamera" );
  if (!pc.IsValid()) return 0;
  csRef<iPcSimpleCamera> pclm =    scfQueryInterface<iPcSimpleCamera> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcSimpleCamera * celGetSimpleCamera (iCelEntity *entity)
{
  csRef<iPcSimpleCamera> pc =    (celQueryPropertyClass<iPcSimpleCamera> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcSimpleCamera *scfQuery_iPcSimpleCamera (iCelPropertyClass *pc)
{
  csRef<iPcSimpleCamera> iface =    scfQueryInterface<iPcSimpleCamera> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcMeshSelect *celCreateMeshSelect(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pcmeshselect" );
  if (!pc.IsValid()) return 0;
  csRef<iPcMeshSelect> pclm =    scfQueryInterface<iPcMeshSelect> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcMeshSelect * celGetMeshSelect (iCelEntity *entity)
{
  csRef<iPcMeshSelect> pc =    (celQueryPropertyClass<iPcMeshSelect> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcMeshSelect *scfQuery_iPcMeshSelect (iCelPropertyClass *pc)
{
  csRef<iPcMeshSelect> iface =    scfQueryInterface<iPcMeshSelect> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcMesh *celCreateMesh(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pcmesh" );
  if (!pc.IsValid()) return 0;
  csRef<iPcMesh> pclm =    scfQueryInterface<iPcMesh> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcMesh * celGetMesh (iCelEntity *entity)
{
  csRef<iPcMesh> pc =    (celQueryPropertyClass<iPcMesh> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcMesh *scfQuery_iPcMesh (iCelPropertyClass *pc)
{
  csRef<iPcMesh> iface =    scfQueryInterface<iPcMesh> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcTimer *celCreateTimer(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pctimer" );
  if (!pc.IsValid()) return 0;
  csRef<iPcTimer> pclm =    scfQueryInterface<iPcTimer> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcTimer * celGetTimer (iCelEntity *entity)
{
  csRef<iPcTimer> pc =    (celQueryPropertyClass<iPcTimer> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcTimer *scfQuery_iPcTimer (iCelPropertyClass *pc)
{
  csRef<iPcTimer> iface =    scfQueryInterface<iPcTimer> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcSolid *celCreateSolid(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pcsolid" );
  if (!pc.IsValid()) return 0;
  csRef<iPcSolid> pclm =    scfQueryInterface<iPcSolid> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcSolid * celGetSolid (iCelEntity *entity)
{
  csRef<iPcSolid> pc =    (celQueryPropertyClass<iPcSolid> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcSolid *scfQuery_iPcSolid (iCelPropertyClass *pc)
{
  csRef<iPcSolid> iface =    scfQueryInterface<iPcSolid> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcGravity *celCreateGravity(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pcgravity" );
  if (!pc.IsValid()) return 0;
  csRef<iPcGravity> pclm =    scfQueryInterface<iPcGravity> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcGravity * celGetGravity (iCelEntity *entity)
{
  csRef<iPcGravity> pc =    (celQueryPropertyClass<iPcGravity> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcGravity *scfQuery_iPcGravity (iCelPropertyClass *pc)
{
  csRef<iPcGravity> iface =    scfQueryInterface<iPcGravity> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcMovable *celCreateMovable(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pcmovable" );
  if (!pc.IsValid()) return 0;
  csRef<iPcMovable> pclm =    scfQueryInterface<iPcMovable> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcMovable * celGetMovable (iCelEntity *entity)
{
  csRef<iPcMovable> pc =    (celQueryPropertyClass<iPcMovable> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcMovable *scfQuery_iPcMovable (iCelPropertyClass *pc)
{
  csRef<iPcMovable> iface =    scfQueryInterface<iPcMovable> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcInventory *celCreateInventory(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pcinventory" );
  if (!pc.IsValid()) return 0;
  csRef<iPcInventory> pclm =    scfQueryInterface<iPcInventory> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcInventory * celGetInventory (iCelEntity *entity)
{
  csRef<iPcInventory> pc =    (celQueryPropertyClass<iPcInventory> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcInventory *scfQuery_iPcInventory (iCelPropertyClass *pc)
{
  csRef<iPcInventory> iface =    scfQueryInterface<iPcInventory> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcCharacteristics *celCreateCharacteristics(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pccharacteristics" );
  if (!pc.IsValid()) return 0;
  csRef<iPcCharacteristics> pclm =    scfQueryInterface<iPcCharacteristics> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcCharacteristics * celGetCharacteristics (iCelEntity *entity)
{
  csRef<iPcCharacteristics> pc =    (celQueryPropertyClass<iPcCharacteristics> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcCharacteristics *scfQuery_iPcCharacteristics (iCelPropertyClass *pc)
{
  csRef<iPcCharacteristics> iface =    scfQueryInterface<iPcCharacteristics> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcTooltip *celCreateToolTip(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pctooltip" );
  if (!pc.IsValid()) return 0;
  csRef<iPcTooltip> pclm =    scfQueryInterface<iPcTooltip> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcTooltip * celGetToolTip (iCelEntity *entity)
{
  csRef<iPcTooltip> pc =    (celQueryPropertyClass<iPcTooltip> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcTooltip *scfQuery_iPcTooltip (iCelPropertyClass *pc)
{
  csRef<iPcTooltip> iface =    scfQueryInterface<iPcTooltip> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcSoundSource *celCreateSoundSource(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pcsoundsource" );
  if (!pc.IsValid()) return 0;
  csRef<iPcSoundSource> pclm =    scfQueryInterface<iPcSoundSource> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcSoundSource * celGetSoundSource (iCelEntity *entity)
{
  csRef<iPcSoundSource> pc =    (celQueryPropertyClass<iPcSoundSource> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcSoundSource *scfQuery_iPcSoundSource (iCelPropertyClass *pc)
{
  csRef<iPcSoundSource> iface =    scfQueryInterface<iPcSoundSource> (pc);
  if (iface) iface->IncRef ();
  return iface;
}


iPcSoundListener *celCreateSoundListener(iCelPlLayer *pl, iCelEntity *entity) {
  csRef<iCelPropertyClass> pc = pl->CreatePropertyClass(entity,"pcsoundlistener" );
  if (!pc.IsValid()) return 0;
  csRef<iPcSoundListener> pclm =    scfQueryInterface<iPcSoundListener> (pc);
  if (!pclm.IsValid()) return 0;
  return pclm;
}


iPcSoundListener * celGetSoundListener (iCelEntity *entity)
{
  csRef<iPcSoundListener> pc =    (celQueryPropertyClass<iPcSoundListener> (entity->GetPropertyClassList ()));
  if (!pc.IsValid()) return 0;
  return pc;
}


iPcSoundListener *scfQuery_iPcSoundListener (iCelPropertyClass *pc)
{
  csRef<iPcSoundListener> iface =    scfQueryInterface<iPcSoundListener> (pc);
  if (iface) iface->IncRef ();
  return iface;
}

#ifdef __cplusplus
extern "C" {
#endif
static PyObject *_wrap_celInitializer_SetupCelPluginDirs(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iObjectRegistry *arg1 = (iObjectRegistry *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celInitializer_SetupCelPluginDirs",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iObjectRegistry, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    celInitializer::SetupCelPluginDirs(arg1);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celInitializer__RequestPlugins(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iObjectRegistry *arg1 = (iObjectRegistry *) 0 ;
    csArray<csPluginRequest > *arg2 = 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celInitializer__RequestPlugins",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iObjectRegistry, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csArrayTcsPluginRequest_csArrayElementHandlerTcsPluginRequest_t_csArrayMemoryAllocatorTcsPluginRequest_t_t, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csArray<csPluginRequest >");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (bool)celInitializer::RequestPlugins(arg1,(csArray<csPluginRequest > const &)*arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_new_celInitializer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    celInitializer *result;
    
    if(!PyArg_ParseTuple(args,(char *)":new_celInitializer")) goto fail;
    result = (celInitializer *)new celInitializer();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_celInitializer, 1);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_celInitializer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    celInitializer *arg1 = (celInitializer *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_celInitializer",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_celInitializer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * celInitializer_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_celInitializer, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iCelNewEntityCallback_NewEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelNewEntityCallback *arg1 = (iCelNewEntityCallback *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelNewEntityCallback_NewEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelNewEntityCallback, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->NewEntity(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iCelNewEntityCallback(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelNewEntityCallback *arg1 = (iCelNewEntityCallback *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iCelNewEntityCallback",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelNewEntityCallback, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iCelNewEntityCallback_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iCelNewEntityCallback, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iCelEntityRemoveCallback_RemoveEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntityRemoveCallback *arg1 = (iCelEntityRemoveCallback *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelEntityRemoveCallback_RemoveEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntityRemoveCallback, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->RemoveEntity(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iCelEntityRemoveCallback(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntityRemoveCallback *arg1 = (iCelEntityRemoveCallback *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iCelEntityRemoveCallback",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntityRemoveCallback, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iCelEntityRemoveCallback_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iCelEntityRemoveCallback, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iCelTimerListener_TickEveryFrame(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelTimerListener *arg1 = (iCelTimerListener *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelTimerListener_TickEveryFrame",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelTimerListener, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->TickEveryFrame();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelTimerListener_TickOnce(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelTimerListener *arg1 = (iCelTimerListener *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelTimerListener_TickOnce",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelTimerListener, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->TickOnce();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iCelTimerListener(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelTimerListener *arg1 = (iCelTimerListener *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iCelTimerListener",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelTimerListener, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iCelTimerListener_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iCelTimerListener, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iCelPlLayer_CreateEntity__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    SwigValueWrapper<csPtr<iCelEntity > > result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelPlLayer_CreateEntity",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (arg1)->CreateEntity();
    
    {
        csPtr<iCelEntity > * resultptr;
        resultptr = new csPtr<iCelEntity >((csPtr<iCelEntity > &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csPtrTiCelEntity_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_CreateEntityInScope(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    int arg2 ;
    SwigValueWrapper<csPtr<iCelEntity > > result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_CreateEntityInScope",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (arg1)->CreateEntityInScope(arg2);
    
    {
        csPtr<iCelEntity > * resultptr;
        resultptr = new csPtr<iCelEntity >((csPtr<iCelEntity > &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csPtrTiCelEntity_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_CreateEntity__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    uint arg2 ;
    SwigValueWrapper<csPtr<iCelEntity > > result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_CreateEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (uint)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (arg1)->CreateEntity(arg2);
    
    {
        csPtr<iCelEntity > * resultptr;
        resultptr = new csPtr<iCelEntity >((csPtr<iCelEntity > &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csPtrTiCelEntity_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_CreateEntity__SWIG_2__varargs__(PyObject *, PyObject *args, PyObject *varargs) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    char *arg2 = (char *) 0 ;
    iCelBlLayer *arg3 = (iCelBlLayer *) 0 ;
    char *arg4 = (char *) 0 ;
    void *arg5 = 0 ;
    SwigValueWrapper<csPtr<iCelEntity > > result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iCelPlLayer_CreateEntity",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_iCelBlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(3)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
        SWIG_arg_fail(4);SWIG_fail;
    }
    result = (arg1)->CreateEntity((char const *)arg2,arg3,(char const *)arg4,arg5);
    
    {
        csPtr<iCelEntity > * resultptr;
        resultptr = new csPtr<iCelEntity >((csPtr<iCelEntity > &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csPtrTiCelEntity_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_CreateEntity__SWIG_2(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *varargs;
    PyObject *newargs;
    
    newargs = PyTuple_GetSlice(args,0,4);
    varargs = PyTuple_GetSlice(args,4,PyTuple_Size(args)+1);
    resultobj = _wrap_iCelPlLayer_CreateEntity__SWIG_2__varargs__(self,newargs,varargs);
    Py_XDECREF(newargs);
    Py_XDECREF(varargs);
    return resultobj;
}


static PyObject *_wrap_iCelPlLayer_RemoveEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_RemoveEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->RemoveEntity(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_RemoveEntities(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelPlLayer_RemoveEntities",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->RemoveEntities();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_CreateEntityTemplate(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    char *arg2 = (char *) 0 ;
    iCelEntityTemplate *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_CreateEntityTemplate",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iCelEntityTemplate *)(arg1)->CreateEntityTemplate((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntityTemplate, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_RemoveEntityTemplate(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntityTemplate *arg2 = (iCelEntityTemplate *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_RemoveEntityTemplate",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntityTemplate, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->RemoveEntityTemplate(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_RemoveEntityTemplates(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelPlLayer_RemoveEntityTemplates",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->RemoveEntityTemplates();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_FindEntityTemplate(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    char *arg2 = (char *) 0 ;
    iCelEntityTemplate *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_FindEntityTemplate",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iCelEntityTemplate *)(arg1)->FindEntityTemplate((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntityTemplate, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_CreateEntity__SWIG_3(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntityTemplate *arg2 = (iCelEntityTemplate *) 0 ;
    char *arg3 = (char *) 0 ;
    celEntityTemplateParams *arg4 = 0 ;
    iCelEntity *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iCelPlLayer_CreateEntity",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntityTemplate, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_csHashTcsStrKey_csStrKey_t, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (arg4 == NULL) {
            SWIG_null_ref("celEntityTemplateParams");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    result = (iCelEntity *)(arg1)->CreateEntity(arg2,(char const *)arg3,(csHash<csStrKey,csStrKey > const &)*arg4);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntity, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_CreateEntity(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[5];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 4); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iCelPlLayer, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            return _wrap_iCelPlLayer_CreateEntity__SWIG_0(self,args);
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iCelPlLayer, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_unsigned_SS_int(argv[1]);
            if (_v) {
                return _wrap_iCelPlLayer_CreateEntity__SWIG_1(self,args);
            }
        }
    }
    if (argc == 4) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iCelPlLayer, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iCelEntityTemplate, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                _v = SWIG_AsCharPtr(argv[2], (char **)(0));
                if (_v) {
                    {
                        void *ptr = 0;
                        if (SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_csHashTcsStrKey_csStrKey_t, 0) == -1) {
                            _v = 0;
                            PyErr_Clear();
                        } else {
                            _v = (ptr != 0);
                        }
                    }
                    if (_v) {
                        return _wrap_iCelPlLayer_CreateEntity__SWIG_3(self,args);
                    }
                }
            }
        }
    }
    if (argc >= 4) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iCelPlLayer, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_AsCharPtr(argv[1], (char **)(0));
            if (_v) {
                {
                    void *ptr;
                    if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_iCelBlLayer, 0) == -1) {
                        _v = 0;
                        PyErr_Clear();
                    } else {
                        _v = 1;
                    }
                }
                if (_v) {
                    _v = SWIG_AsCharPtr(argv[3], (char **)(0));
                    if (_v) {
                        if (argc <= 4) {
                            return _wrap_iCelPlLayer_CreateEntity__SWIG_2(self,args);
                        }
                        return _wrap_iCelPlLayer_CreateEntity__SWIG_2(self,args);
                    }
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iCelPlLayer_CreateEntity'");
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_CreateMessage__varargs__(PyObject *, PyObject *args, PyObject *varargs) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    char *arg2 = (char *) 0 ;
    void *arg3 = 0 ;
    SwigValueWrapper<csPtr<iCelMessage > > result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_CreateMessage",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (arg1)->CreateMessage((char const *)arg2,arg3);
    
    {
        csPtr<iCelMessage > * resultptr;
        resultptr = new csPtr<iCelMessage >((csPtr<iCelMessage > &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csPtrTiCelMessage_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_CreateMessage(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *varargs;
    PyObject *newargs;
    
    newargs = PyTuple_GetSlice(args,0,2);
    varargs = PyTuple_GetSlice(args,2,PyTuple_Size(args)+1);
    resultobj = _wrap_iCelPlLayer_CreateMessage__varargs__(self,newargs,varargs);
    Py_XDECREF(newargs);
    Py_XDECREF(varargs);
    return resultobj;
}


static PyObject *_wrap_iCelPlLayer_CreateDataBuffer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    long arg2 ;
    SwigValueWrapper<csPtr<iCelDataBuffer > > result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_CreateDataBuffer",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (long)(SWIG_As_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (arg1)->CreateDataBuffer(arg2);
    
    {
        csPtr<iCelDataBuffer > * resultptr;
        resultptr = new csPtr<iCelDataBuffer >((csPtr<iCelDataBuffer > &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csPtrTiCelDataBuffer_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_AttachEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iObject *arg2 = (iObject *) 0 ;
    iCelEntity *arg3 = (iCelEntity *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelPlLayer_AttachEntity",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(3)) SWIG_fail;
    (arg1)->AttachEntity(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_UnattachEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iObject *arg2 = (iObject *) 0 ;
    iCelEntity *arg3 = (iCelEntity *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelPlLayer_UnattachEntity",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(3)) SWIG_fail;
    (arg1)->UnattachEntity(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_GetEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    uint arg2 ;
    iCelEntity *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_GetEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (uint)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (iCelEntity *)(arg1)->GetEntity(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntity, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_GetEntityCount(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    size_t result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelPlLayer_GetEntityCount",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = ((iCelPlLayer const *)arg1)->GetEntityCount();
    
    {
        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_GetEntityByIndex(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    size_t arg2 ;
    iCelEntity *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_GetEntityByIndex",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (iCelEntity *)((iCelPlLayer const *)arg1)->GetEntityByIndex(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntity, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_FindEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    char *arg2 = (char *) 0 ;
    iCelEntity *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_FindEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iCelEntity *)(arg1)->FindEntity((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntity, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_GetBehaviour(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    uint arg2 ;
    iCelBehaviour *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_GetBehaviour",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (uint)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (iCelBehaviour *)(arg1)->GetBehaviour(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelBehaviour, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_FindAttachedEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iObject *arg2 = (iObject *) 0 ;
    iCelEntity *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_FindAttachedEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iCelEntity *)(arg1)->FindAttachedEntity(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntity, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_FindNearbyEntities__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iSector *arg2 = (iSector *) 0 ;
    csVector3 *arg3 = 0 ;
    float arg4 ;
    SwigValueWrapper<csPtr<iCelEntityList > > result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iCelPlLayer_FindNearbyEntities",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iSector, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (float)(SWIG_As_float(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    result = (arg1)->FindNearbyEntities(arg2,(csVector3 const &)*arg3,arg4);
    
    {
        csPtr<iCelEntityList > * resultptr;
        resultptr = new csPtr<iCelEntityList >((csPtr<iCelEntityList > &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csPtrTiCelEntityList_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_FindNearbyEntities__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iSector *arg2 = (iSector *) 0 ;
    csBox3 *arg3 = 0 ;
    SwigValueWrapper<csPtr<iCelEntityList > > result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelPlLayer_FindNearbyEntities",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iSector, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_csBox3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csBox3");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (arg1)->FindNearbyEntities(arg2,(csBox3 const &)*arg3);
    
    {
        csPtr<iCelEntityList > * resultptr;
        resultptr = new csPtr<iCelEntityList >((csPtr<iCelEntityList > &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csPtrTiCelEntityList_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_FindNearbyEntities(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[5];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 4); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iCelPlLayer, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iSector, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                {
                    void *ptr = 0;
                    if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_csBox3, 0) == -1) {
                        _v = 0;
                        PyErr_Clear();
                    } else {
                        _v = (ptr != 0);
                    }
                }
                if (_v) {
                    return _wrap_iCelPlLayer_FindNearbyEntities__SWIG_1(self,args);
                }
            }
        }
    }
    if (argc == 4) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iCelPlLayer, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iSector, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                {
                    void *ptr = 0;
                    if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_csVector3, 0) == -1) {
                        _v = 0;
                        PyErr_Clear();
                    } else {
                        _v = (ptr != 0);
                    }
                }
                if (_v) {
                    _v = SWIG_Check_float(argv[3]);
                    if (_v) {
                        return _wrap_iCelPlLayer_FindNearbyEntities__SWIG_0(self,args);
                    }
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iCelPlLayer_FindNearbyEntities'");
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_GetHitEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCamera *arg2 = (iCamera *) 0 ;
    int arg3 ;
    int arg4 ;
    iCelEntity *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iCelPlLayer_GetHitEntity",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (int)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    result = (iCelEntity *)(arg1)->GetHitEntity(arg2,arg3,arg4);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntity, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_CreateEmptyEntityList(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    SwigValueWrapper<csPtr<iCelEntityList > > result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelPlLayer_CreateEmptyEntityList",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (arg1)->CreateEmptyEntityList();
    
    {
        csPtr<iCelEntityList > * resultptr;
        resultptr = new csPtr<iCelEntityList >((csPtr<iCelEntityList > &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csPtrTiCelEntityList_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_CreateEntityTracker(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    char *arg2 = (char *) 0 ;
    iCelEntityTracker *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_CreateEntityTracker",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iCelEntityTracker *)(arg1)->CreateEntityTracker((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntityTracker, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_FindEntityTracker(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    char *arg2 = (char *) 0 ;
    iCelEntityTracker *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_FindEntityTracker",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iCelEntityTracker *)(arg1)->FindEntityTracker((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntityTracker, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_RemoveEntityTracker(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntityTracker *arg2 = (iCelEntityTracker *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_RemoveEntityTracker",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntityTracker, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->RemoveEntityTracker(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_SetEntityAddonAllowed(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_SetEntityAddonAllowed",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetEntityAddonAllowed(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_IsEntityAddonAllowed(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelPlLayer_IsEntityAddonAllowed",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iCelPlLayer const *)arg1)->IsEntityAddonAllowed();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_LoadPropertyClassFactory(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    char *arg2 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_LoadPropertyClassFactory",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (bool)(arg1)->LoadPropertyClassFactory((char const *)arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_RegisterPropertyClassFactory(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelPropertyClassFactory *arg2 = (iCelPropertyClassFactory *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_RegisterPropertyClassFactory",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelPropertyClassFactory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->RegisterPropertyClassFactory(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_UnregisterPropertyClassFactory(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelPropertyClassFactory *arg2 = (iCelPropertyClassFactory *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_UnregisterPropertyClassFactory",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelPropertyClassFactory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->UnregisterPropertyClassFactory(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_GetPropertyClassFactoryCount(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    size_t result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelPlLayer_GetPropertyClassFactoryCount",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = ((iCelPlLayer const *)arg1)->GetPropertyClassFactoryCount();
    
    {
        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_GetPropertyClassFactory(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    size_t arg2 ;
    iCelPropertyClassFactory *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_GetPropertyClassFactory",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (iCelPropertyClassFactory *)((iCelPlLayer const *)arg1)->GetPropertyClassFactory(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelPropertyClassFactory, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_FindPropertyClassFactory(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    char *arg2 = (char *) 0 ;
    iCelPropertyClassFactory *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_FindPropertyClassFactory",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iCelPropertyClassFactory *)((iCelPlLayer const *)arg1)->FindPropertyClassFactory((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelPropertyClassFactory, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_CreatePropertyClass(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    char *arg3 = (char *) 0 ;
    iCelPropertyClass *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelPlLayer_CreatePropertyClass",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    result = (iCelPropertyClass *)(arg1)->CreatePropertyClass(arg2,(char const *)arg3);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelPropertyClass, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_CreateTaggedPropertyClass(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    char *arg3 = (char *) 0 ;
    char *arg4 = (char *) 0 ;
    iCelPropertyClass *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iCelPlLayer_CreateTaggedPropertyClass",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
        SWIG_arg_fail(4);SWIG_fail;
    }
    result = (iCelPropertyClass *)(arg1)->CreateTaggedPropertyClass(arg2,(char const *)arg3,(char const *)arg4);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelPropertyClass, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_RegisterBehaviourLayer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelBlLayer *arg2 = (iCelBlLayer *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_RegisterBehaviourLayer",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelBlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->RegisterBehaviourLayer(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_UnregisterBehaviourLayer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelBlLayer *arg2 = (iCelBlLayer *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_UnregisterBehaviourLayer",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelBlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->UnregisterBehaviourLayer(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_GetBehaviourLayerCount(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    size_t result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelPlLayer_GetBehaviourLayerCount",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = ((iCelPlLayer const *)arg1)->GetBehaviourLayerCount();
    
    {
        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_GetBehaviourLayer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    size_t arg2 ;
    iCelBlLayer *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_GetBehaviourLayer",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (iCelBlLayer *)((iCelPlLayer const *)arg1)->GetBehaviourLayer(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelBlLayer, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_FindBehaviourLayer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    char *arg2 = (char *) 0 ;
    iCelBlLayer *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_FindBehaviourLayer",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iCelBlLayer *)((iCelPlLayer const *)arg1)->FindBehaviourLayer((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelBlLayer, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_Cache(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iBase *arg2 = (iBase *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_Cache",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iBase, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->Cache(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_Uncache(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iBase *arg2 = (iBase *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_Uncache",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iBase, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->Uncache(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_CleanCache(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelPlLayer_CleanCache",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->CleanCache();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_FetchStringID(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    char *arg2 = (char *) 0 ;
    csStringID result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_FetchStringID",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (csStringID)(arg1)->FetchStringID((char const *)arg2);
    
    {
        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_FetchString(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    csStringID arg2 ;
    char *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_FetchString",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (char *)(arg1)->FetchString(arg2);
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_AddEntityRemoveCallback(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntityRemoveCallback *arg2 = (iCelEntityRemoveCallback *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_AddEntityRemoveCallback",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntityRemoveCallback, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->AddEntityRemoveCallback(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_RemoveEntityRemoveCallback(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntityRemoveCallback *arg2 = (iCelEntityRemoveCallback *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_RemoveEntityRemoveCallback",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntityRemoveCallback, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->RemoveEntityRemoveCallback(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_AddNewEntityCallback(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelNewEntityCallback *arg2 = (iCelNewEntityCallback *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_AddNewEntityCallback",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelNewEntityCallback, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->AddNewEntityCallback(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_RemoveNewEntityCallback(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelNewEntityCallback *arg2 = (iCelNewEntityCallback *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPlLayer_RemoveNewEntityCallback",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelNewEntityCallback, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->RemoveNewEntityCallback(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_CallbackEveryFrame(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelTimerListener *arg2 = (iCelTimerListener *) 0 ;
    int arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelPlLayer_CallbackEveryFrame",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelTimerListener, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->CallbackEveryFrame(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_CallbackOnce(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelTimerListener *arg2 = (iCelTimerListener *) 0 ;
    csTicks arg3 ;
    int arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iCelPlLayer_CallbackOnce",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelTimerListener, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        arg3 = (csTicks)(SWIG_As_unsigned_SS_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (int)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    (arg1)->CallbackOnce(arg2,arg3,arg4);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_RemoveCallbackEveryFrame(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelTimerListener *arg2 = (iCelTimerListener *) 0 ;
    int arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelPlLayer_RemoveCallbackEveryFrame",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelTimerListener, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->RemoveCallbackEveryFrame(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_RemoveCallbackOnce(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelTimerListener *arg2 = (iCelTimerListener *) 0 ;
    int arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelPlLayer_RemoveCallbackOnce",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelTimerListener, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->RemoveCallbackOnce(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPlLayer_AddScope(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    csString arg2 ;
    int arg3 ;
    int result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelPlLayer_AddScope",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        csString * argp;
        SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_csString, SWIG_POINTER_EXCEPTION);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (argp == NULL) {
            SWIG_null_ref("csString");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
        arg2 = *argp;
    }
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (int)(arg1)->AddScope(arg2,arg3);
    
    {
        resultobj = SWIG_From_int((int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iCelPlLayer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iCelPlLayer",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iCelPlLayer_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iCelPlLayer, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iCelEntityTracker_GetName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntityTracker *arg1 = (iCelEntityTracker *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelEntityTracker_GetName",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntityTracker, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)((iCelEntityTracker const *)arg1)->GetName();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelEntityTracker_AddEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntityTracker *arg1 = (iCelEntityTracker *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelEntityTracker_AddEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntityTracker, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->AddEntity(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelEntityTracker_RemoveEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntityTracker *arg1 = (iCelEntityTracker *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelEntityTracker_RemoveEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntityTracker, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->RemoveEntity(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelEntityTracker_RemoveEntities(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntityTracker *arg1 = (iCelEntityTracker *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelEntityTracker_RemoveEntities",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntityTracker, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->RemoveEntities();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelEntityTracker_FindNearbyEntities(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntityTracker *arg1 = (iCelEntityTracker *) 0 ;
    iSector *arg2 = (iSector *) 0 ;
    csVector3 *arg3 = 0 ;
    float arg4 ;
    SwigValueWrapper<csPtr<iCelEntityList > > result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iCelEntityTracker_FindNearbyEntities",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntityTracker, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iSector, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (float)(SWIG_As_float(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    result = (arg1)->FindNearbyEntities(arg2,(csVector3 const &)*arg3,arg4);
    
    {
        csPtr<iCelEntityList > * resultptr;
        resultptr = new csPtr<iCelEntityList >((csPtr<iCelEntityList > &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csPtrTiCelEntityList_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iCelEntityTracker(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntityTracker *arg1 = (iCelEntityTracker *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iCelEntityTracker",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntityTracker, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iCelEntityTracker_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iCelEntityTracker, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_csQueryRegistry_iCelPlLayer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iObjectRegistry *arg1 = (iObjectRegistry *) 0 ;
    iCelPlLayer *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:csQueryRegistry_iCelPlLayer",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iObjectRegistry, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iCelPlLayer *)csQueryRegistry_iCelPlLayer(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelPlLayer, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelEntity_QueryObject(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelEntity_QueryObject",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iObject *)(arg1)->QueryObject();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iObject, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelEntity_GetName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelEntity_GetName",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)((iCelEntity const *)arg1)->GetName();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelEntity_SetName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelEntity_SetName",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->SetName((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelEntity_GetID(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    uint result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelEntity_GetID",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (uint)((iCelEntity const *)arg1)->GetID();
    
    {
        resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelEntity_SetID(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    uint arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelEntity_SetID",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (uint)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetID(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelEntity_GetPropertyClassList(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iCelPropertyClassList *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelEntity_GetPropertyClassList",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iCelPropertyClassList *)(arg1)->GetPropertyClassList();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelPropertyClassList, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelEntity_SetBehaviour(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iCelBehaviour *arg2 = (iCelBehaviour *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelEntity_SetBehaviour",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelBehaviour, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetBehaviour(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelEntity_GetBehaviour(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iCelBehaviour *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelEntity_GetBehaviour",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iCelBehaviour *)(arg1)->GetBehaviour();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelBehaviour, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelEntity_CreateBehaviour(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iCelBlLayer *arg2 = (iCelBlLayer *) 0 ;
    char *arg3 = (char *) 0 ;
    iCelBehaviour *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelEntity_CreateBehaviour",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelBlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    result = (iCelBehaviour *)iCelEntity_CreateBehaviour(arg1,arg2,(char const *)arg3);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelBehaviour, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iCelEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iCelEntity",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iCelEntity_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iCelEntity, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iCelEntityList_GetCount(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntityList *arg1 = (iCelEntityList *) 0 ;
    size_t result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelEntityList_GetCount",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntityList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = ((iCelEntityList const *)arg1)->GetCount();
    
    {
        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelEntityList_Get(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntityList *arg1 = (iCelEntityList *) 0 ;
    size_t arg2 ;
    iCelEntity *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelEntityList_Get",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntityList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (iCelEntity *)((iCelEntityList const *)arg1)->Get(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntity, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelEntityList_Add(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntityList *arg1 = (iCelEntityList *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    size_t result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelEntityList_Add",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntityList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (arg1)->Add(arg2);
    
    {
        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelEntityList_Remove__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntityList *arg1 = (iCelEntityList *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelEntityList_Remove",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntityList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->Remove(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelEntityList_Remove__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntityList *arg1 = (iCelEntityList *) 0 ;
    size_t arg2 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelEntityList_Remove",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntityList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (bool)(arg1)->Remove(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelEntityList_Remove(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[3];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iCelEntityList, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iCelEntity, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                return _wrap_iCelEntityList_Remove__SWIG_0(self,args);
            }
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iCelEntityList, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_unsigned_SS_long(argv[1]);
            if (_v) {
                return _wrap_iCelEntityList_Remove__SWIG_1(self,args);
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iCelEntityList_Remove'");
    return NULL;
}


static PyObject *_wrap_iCelEntityList_RemoveAll(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntityList *arg1 = (iCelEntityList *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelEntityList_RemoveAll",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntityList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->RemoveAll();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelEntityList_Find(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntityList *arg1 = (iCelEntityList *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    size_t result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelEntityList_Find",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntityList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = ((iCelEntityList const *)arg1)->Find(arg2);
    
    {
        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelEntityList_FindByName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntityList *arg1 = (iCelEntityList *) 0 ;
    char *arg2 = (char *) 0 ;
    iCelEntity *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelEntityList_FindByName",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntityList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iCelEntity *)((iCelEntityList const *)arg1)->FindByName((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntity, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iCelEntityList(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntityList *arg1 = (iCelEntityList *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iCelEntityList",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntityList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iCelEntityList_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iCelEntityList, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celRegisterPCFactory(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iObjectRegistry *arg1 = (iObjectRegistry *) 0 ;
    char *arg2 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celRegisterPCFactory",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iObjectRegistry, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (bool)celRegisterPCFactory(arg1,(char const *)arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celCreateEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    char *arg2 = (char *) 0 ;
    iCelEntity *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iCelEntity *)celCreateEntity(arg1,(char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntity, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQueryInterface_iCelEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBase *arg1 = (iBase *) 0 ;
    iCelEntity *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQueryInterface_iCelEntity",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBase, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iCelEntity *)scfQueryInterface_iCelEntity(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntity, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celFindNearbyEntities(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iObjectRegistry *arg1 = (iObjectRegistry *) 0 ;
    iSector *arg2 = (iSector *) 0 ;
    csVector3 arg3 ;
    float arg4 ;
    iCelEntityList *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:celFindNearbyEntities",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iObjectRegistry, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iSector, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        csVector3 * argp;
        SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (argp == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
        arg3 = *argp;
    }
    {
        arg4 = (float)(SWIG_As_float(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    result = (iCelEntityList *)celFindNearbyEntities(arg1,arg2,arg3,arg4);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntityList, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelBlLayer_GetName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelBlLayer *arg1 = (iCelBlLayer *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelBlLayer_GetName",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelBlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)((iCelBlLayer const *)arg1)->GetName();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelBlLayer_CreateBehaviour(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelBlLayer *arg1 = (iCelBlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    char *arg3 = (char *) 0 ;
    iCelBehaviour *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelBlLayer_CreateBehaviour",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelBlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    result = (iCelBehaviour *)(arg1)->CreateBehaviour(arg2,(char const *)arg3);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelBehaviour, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iCelBlLayer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelBlLayer *arg1 = (iCelBlLayer *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iCelBlLayer",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelBlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iCelBlLayer_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iCelBlLayer, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_csQueryRegistry_iCelBlLayer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iObjectRegistry *arg1 = (iObjectRegistry *) 0 ;
    iCelBlLayer *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:csQueryRegistry_iCelBlLayer",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iObjectRegistry, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iCelBlLayer *)csQueryRegistry_iCelBlLayer(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelBlLayer, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelParameterBlock_GetParameterCount(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelParameterBlock *arg1 = (iCelParameterBlock *) 0 ;
    size_t result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelParameterBlock_GetParameterCount",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelParameterBlock, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = ((iCelParameterBlock const *)arg1)->GetParameterCount();
    
    {
        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelParameterBlock_GetParameter__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelParameterBlock *arg1 = (iCelParameterBlock *) 0 ;
    size_t arg2 ;
    csStringID *arg3 = 0 ;
    celDataType *arg4 = 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iCelParameterBlock_GetParameter",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelParameterBlock, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_long, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csStringID");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_celDataType, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (arg4 == NULL) {
            SWIG_null_ref("celDataType");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    result = (char *)((iCelParameterBlock const *)arg1)->GetParameter(arg2,*arg3,(enum celDataType &)*arg4);
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelParameterBlock_GetParameter__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelParameterBlock *arg1 = (iCelParameterBlock *) 0 ;
    csStringID arg2 ;
    celData *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelParameterBlock_GetParameter",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelParameterBlock, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (celData *)((iCelParameterBlock const *)arg1)->GetParameter(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_celData, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelParameterBlock_GetParameter(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[5];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 4); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iCelParameterBlock, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_unsigned_SS_long(argv[1]);
            if (_v) {
                return _wrap_iCelParameterBlock_GetParameter__SWIG_1(self,args);
            }
        }
    }
    if (argc == 4) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iCelParameterBlock, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_unsigned_SS_long(argv[1]);
            if (_v) {
                {
                    void *ptr = 0;
                    if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_unsigned_long, 0) == -1) {
                        _v = 0;
                        PyErr_Clear();
                    } else {
                        _v = (ptr != 0);
                    }
                }
                if (_v) {
                    {
                        void *ptr = 0;
                        if (SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_celDataType, 0) == -1) {
                            _v = 0;
                            PyErr_Clear();
                        } else {
                            _v = (ptr != 0);
                        }
                    }
                    if (_v) {
                        return _wrap_iCelParameterBlock_GetParameter__SWIG_0(self,args);
                    }
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iCelParameterBlock_GetParameter'");
    return NULL;
}


static PyObject *_wrap_iCelParameterBlock_GetParameterValue(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelParameterBlock *arg1 = (iCelParameterBlock *) 0 ;
    csStringID arg2 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelParameterBlock_GetParameterValue",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelParameterBlock, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (PyObject *)iCelParameterBlock_GetParameterValue(arg1,arg2);
    
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iCelParameterBlock(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelParameterBlock *arg1 = (iCelParameterBlock *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iCelParameterBlock",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelParameterBlock, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iCelParameterBlock_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iCelParameterBlock, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iCelBehaviour_GetName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelBehaviour *arg1 = (iCelBehaviour *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelBehaviour_GetName",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelBehaviour, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)((iCelBehaviour const *)arg1)->GetName();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelBehaviour_GetBehaviourLayer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelBehaviour *arg1 = (iCelBehaviour *) 0 ;
    iCelBlLayer *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelBehaviour_GetBehaviourLayer",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelBehaviour, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iCelBlLayer *)((iCelBehaviour const *)arg1)->GetBehaviourLayer();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelBlLayer, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelBehaviour_SendMessage__varargs__(PyObject *, PyObject *args, PyObject *varargs) {
    PyObject *resultobj;
    iCelBehaviour *arg1 = (iCelBehaviour *) 0 ;
    char *arg2 = (char *) 0 ;
    iCelPropertyClass *arg3 = (iCelPropertyClass *) 0 ;
    celData *arg4 = 0 ;
    iCelParameterBlock *arg5 = (iCelParameterBlock *) 0 ;
    void *arg6 = 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:iCelBehaviour_SendMessage",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelBehaviour, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(3)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_celData, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (arg4 == NULL) {
            SWIG_null_ref("celData");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_iCelParameterBlock, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(5)) SWIG_fail;
    result = (bool)(arg1)->SendMessage((char const *)arg2,arg3,*arg4,arg5,arg6);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelBehaviour_SendMessage(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *varargs;
    PyObject *newargs;
    
    newargs = PyTuple_GetSlice(args,0,5);
    varargs = PyTuple_GetSlice(args,5,PyTuple_Size(args)+1);
    resultobj = _wrap_iCelBehaviour_SendMessage__varargs__(self,newargs,varargs);
    Py_XDECREF(newargs);
    Py_XDECREF(varargs);
    return resultobj;
}


static PyObject *_wrap_iCelBehaviour_GetInternalObject(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelBehaviour *arg1 = (iCelBehaviour *) 0 ;
    void *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelBehaviour_GetInternalObject",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelBehaviour, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (void *)(arg1)->GetInternalObject();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_void, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelBehaviour_GetPythonObject(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelBehaviour *arg1 = (iCelBehaviour *) 0 ;
    PyObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelBehaviour_GetPythonObject",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelBehaviour, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (PyObject *)iCelBehaviour_GetPythonObject(arg1);
    
    resultobj = result;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iCelBehaviour(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelBehaviour *arg1 = (iCelBehaviour *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iCelBehaviour",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelBehaviour, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iCelBehaviour_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iCelBehaviour, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iCelPropertyClass_GetName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelPropertyClass_GetName",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)((iCelPropertyClass const *)arg1)->GetName();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_SetTag(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClass_SetTag",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->SetTag((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_GetTag(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelPropertyClass_GetTag",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)((iCelPropertyClass const *)arg1)->GetTag();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_GetEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iCelEntity *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelPropertyClass_GetEntity",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iCelEntity *)(arg1)->GetEntity();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntity, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_SetEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClass_SetEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetEntity(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_SaveFirstPass(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    SwigValueWrapper<csPtr<iCelDataBuffer > > result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelPropertyClass_SaveFirstPass",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (arg1)->SaveFirstPass();
    
    {
        csPtr<iCelDataBuffer > * resultptr;
        resultptr = new csPtr<iCelDataBuffer >((csPtr<iCelDataBuffer > &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csPtrTiCelDataBuffer_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_LoadFirstPass(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iCelDataBuffer *arg2 = (iCelDataBuffer *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClass_LoadFirstPass",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelDataBuffer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->LoadFirstPass(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_Save(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    SwigValueWrapper<csPtr<iCelDataBuffer > > result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelPropertyClass_Save",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (arg1)->Save();
    
    {
        csPtr<iCelDataBuffer > * resultptr;
        resultptr = new csPtr<iCelDataBuffer >((csPtr<iCelDataBuffer > &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csPtrTiCelDataBuffer_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_Load(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iCelDataBuffer *arg2 = (iCelDataBuffer *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClass_Load",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelDataBuffer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->Load(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_AddPropertyChangeCallback(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iCelPropertyChangeCallback *arg2 = (iCelPropertyChangeCallback *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClass_AddPropertyChangeCallback",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelPropertyChangeCallback, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->AddPropertyChangeCallback(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_RemovePropertyChangeCallback(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iCelPropertyChangeCallback *arg2 = (iCelPropertyChangeCallback *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClass_RemovePropertyChangeCallback",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelPropertyChangeCallback, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->RemovePropertyChangeCallback(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_GetPropertyOrActionType(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    csStringID arg2 ;
    celDataType result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClass_GetPropertyOrActionType",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (celDataType)(arg1)->GetPropertyOrActionType(arg2);
    
    resultobj = SWIG_From_int((result));
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_IsPropertyReadOnly(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    csStringID arg2 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClass_IsPropertyReadOnly",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (bool)(arg1)->IsPropertyReadOnly(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_GetPropertyLong(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    csStringID arg2 ;
    long result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClass_GetPropertyLong",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (long)(arg1)->GetPropertyLong(arg2);
    
    {
        resultobj = SWIG_From_long((long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_GetPropertyFloat(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    csStringID arg2 ;
    float result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClass_GetPropertyFloat",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (float)(arg1)->GetPropertyFloat(arg2);
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_GetPropertyBool(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    csStringID arg2 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClass_GetPropertyBool",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (bool)(arg1)->GetPropertyBool(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_GetPropertyString(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    csStringID arg2 ;
    char *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClass_GetPropertyString",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (char *)(arg1)->GetPropertyString(arg2);
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_GetPropertyVector__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    csStringID arg2 ;
    csVector2 *arg3 = 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelPropertyClass_GetPropertyVector",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_csVector2, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csVector2");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (bool)(arg1)->GetPropertyVector(arg2,*arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_GetPropertyVector__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    csStringID arg2 ;
    csVector3 *arg3 = 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelPropertyClass_GetPropertyVector",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (bool)(arg1)->GetPropertyVector(arg2,*arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_GetPropertyVector(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[4];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iCelPropertyClass, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_unsigned_SS_long(argv[1]);
            if (_v) {
                {
                    void *ptr = 0;
                    if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_csVector2, 0) == -1) {
                        _v = 0;
                        PyErr_Clear();
                    } else {
                        _v = (ptr != 0);
                    }
                }
                if (_v) {
                    return _wrap_iCelPropertyClass_GetPropertyVector__SWIG_0(self,args);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iCelPropertyClass, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_unsigned_SS_long(argv[1]);
            if (_v) {
                {
                    void *ptr = 0;
                    if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_csVector3, 0) == -1) {
                        _v = 0;
                        PyErr_Clear();
                    } else {
                        _v = (ptr != 0);
                    }
                }
                if (_v) {
                    return _wrap_iCelPropertyClass_GetPropertyVector__SWIG_1(self,args);
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iCelPropertyClass_GetPropertyVector'");
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_GetPropertyColor(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    csStringID arg2 ;
    csColor *arg3 = 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelPropertyClass_GetPropertyColor",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_csColor, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csColor");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (bool)(arg1)->GetPropertyColor(arg2,*arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_GetPropertyPClass(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    csStringID arg2 ;
    iCelPropertyClass *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClass_GetPropertyPClass",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (iCelPropertyClass *)(arg1)->GetPropertyPClass(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelPropertyClass, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_GetPropertyEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    csStringID arg2 ;
    iCelEntity *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClass_GetPropertyEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (iCelEntity *)(arg1)->GetPropertyEntity(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntity, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_PerformAction(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    csStringID arg2 ;
    iCelParameterBlock *arg3 = (iCelParameterBlock *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelPropertyClass_PerformAction",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_iCelParameterBlock, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(3)) SWIG_fail;
    result = (bool)(arg1)->PerformAction(arg2,arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_GetPropertyAndActionCount(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    size_t result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelPropertyClass_GetPropertyAndActionCount",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = ((iCelPropertyClass const *)arg1)->GetPropertyAndActionCount();
    
    {
        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_GetPropertyOrActionID(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    size_t arg2 ;
    csStringID result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClass_GetPropertyOrActionID",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (csStringID)(arg1)->GetPropertyOrActionID(arg2);
    
    {
        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_GetPropertyOrActionDescription(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    csStringID arg2 ;
    char *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClass_GetPropertyOrActionDescription",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (char *)(arg1)->GetPropertyOrActionDescription(arg2);
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_PropertyClassesHaveChanged(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelPropertyClass_PropertyClassesHaveChanged",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->PropertyClassesHaveChanged();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_GetPersistentData(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    celPersistenceType arg2 ;
    SwigValueWrapper<csPtr<iCelDataBuffer > > result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClass_GetPersistentData",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        celPersistenceType * argp;
        SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_celPersistenceType, SWIG_POINTER_EXCEPTION);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (argp == NULL) {
            SWIG_null_ref("celPersistenceType");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
        arg2 = *argp;
    }
    result = (arg1)->GetPersistentData(arg2);
    
    {
        csPtr<iCelDataBuffer > * resultptr;
        resultptr = new csPtr<iCelDataBuffer >((csPtr<iCelDataBuffer > &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csPtrTiCelDataBuffer_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_SetPersistentData(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    csTicks arg2 ;
    iCelDataBuffer *arg3 = (iCelDataBuffer *) 0 ;
    celPersistenceType arg4 ;
    celPersistenceResult result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iCelPropertyClass_SetPersistentData",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csTicks)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_iCelDataBuffer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(3)) SWIG_fail;
    {
        celPersistenceType * argp;
        SWIG_Python_ConvertPtr(obj3, (void **)&argp, SWIGTYPE_p_celPersistenceType, SWIG_POINTER_EXCEPTION);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (argp == NULL) {
            SWIG_null_ref("celPersistenceType");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
        arg4 = *argp;
    }
    result = (arg1)->SetPersistentData(arg2,arg3,arg4);
    
    {
        celPersistenceResult * resultptr;
        resultptr = new celPersistenceResult((celPersistenceResult &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_celPersistenceResult, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_SetPropertyLong(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    csStringID arg2 ;
    long arg3 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelPropertyClass_SetPropertyLong",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (long)(SWIG_As_long(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (bool)iCelPropertyClass_SetPropertyLong(arg1,arg2,arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_SetPropertyFloat(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    csStringID arg2 ;
    float arg3 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelPropertyClass_SetPropertyFloat",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (bool)iCelPropertyClass_SetPropertyFloat(arg1,arg2,arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_SetPropertyBool(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    csStringID arg2 ;
    bool arg3 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelPropertyClass_SetPropertyBool",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (bool)(SWIG_As_bool(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (bool)iCelPropertyClass_SetPropertyBool(arg1,arg2,arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_SetPropertyString(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    csStringID arg2 ;
    char *arg3 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelPropertyClass_SetPropertyString",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    result = (bool)iCelPropertyClass_SetPropertyString(arg1,arg2,(char const *)arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClass_SetPropertyVector3(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    csStringID arg2 ;
    csVector3 *arg3 = 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelPropertyClass_SetPropertyVector3",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csStringID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (bool)iCelPropertyClass_SetPropertyVector3(arg1,arg2,(csVector3 const &)*arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iCelPropertyClass(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iCelPropertyClass",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iCelPropertyClass_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iCelPropertyClass, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iCelPropertyClassList_GetCount(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    size_t result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelPropertyClassList_GetCount",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = ((iCelPropertyClassList const *)arg1)->GetCount();
    
    {
        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClassList_Get(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    size_t arg2 ;
    iCelPropertyClass *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClassList_Get",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (iCelPropertyClass *)((iCelPropertyClassList const *)arg1)->Get(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelPropertyClass, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClassList_Add(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    iCelPropertyClass *arg2 = (iCelPropertyClass *) 0 ;
    size_t result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClassList_Add",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (arg1)->Add(arg2);
    
    {
        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClassList_Remove__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    iCelPropertyClass *arg2 = (iCelPropertyClass *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClassList_Remove",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->Remove(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClassList_Remove__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    size_t arg2 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClassList_Remove",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (bool)(arg1)->Remove(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClassList_Remove(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[3];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iCelPropertyClassList, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iCelPropertyClass, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                return _wrap_iCelPropertyClassList_Remove__SWIG_0(self,args);
            }
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iCelPropertyClassList, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_unsigned_SS_long(argv[1]);
            if (_v) {
                return _wrap_iCelPropertyClassList_Remove__SWIG_1(self,args);
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iCelPropertyClassList_Remove'");
    return NULL;
}


static PyObject *_wrap_iCelPropertyClassList_RemoveByInterface(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    scfInterfaceID arg2 ;
    int arg3 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelPropertyClassList_RemoveByInterface",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (scfInterfaceID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (bool)(arg1)->RemoveByInterface(arg2,arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClassList_RemoveByInterfaceAndTag(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    scfInterfaceID arg2 ;
    int arg3 ;
    char *arg4 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iCelPropertyClassList_RemoveByInterfaceAndTag",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (scfInterfaceID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
        SWIG_arg_fail(4);SWIG_fail;
    }
    result = (bool)(arg1)->RemoveByInterfaceAndTag(arg2,arg3,(char const *)arg4);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClassList_RemoveAll(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelPropertyClassList_RemoveAll",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->RemoveAll();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClassList_Find(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    iCelPropertyClass *arg2 = (iCelPropertyClass *) 0 ;
    size_t result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClassList_Find",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = ((iCelPropertyClassList const *)arg1)->Find(arg2);
    
    {
        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClassList_FindByName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    char *arg2 = (char *) 0 ;
    iCelPropertyClass *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelPropertyClassList_FindByName",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iCelPropertyClass *)((iCelPropertyClassList const *)arg1)->FindByName((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelPropertyClass, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClassList_FindByNameAndTag(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    char *arg2 = (char *) 0 ;
    char *arg3 = (char *) 0 ;
    iCelPropertyClass *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelPropertyClassList_FindByNameAndTag",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    result = (iCelPropertyClass *)((iCelPropertyClassList const *)arg1)->FindByNameAndTag((char const *)arg2,(char const *)arg3);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelPropertyClass, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClassList_FindByInterface(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    scfInterfaceID arg2 ;
    int arg3 ;
    iBase *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelPropertyClassList_FindByInterface",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (scfInterfaceID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (iBase *)((iCelPropertyClassList const *)arg1)->FindByInterface(arg2,arg3);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iBase, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelPropertyClassList_FindByInterfaceAndTag(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    scfInterfaceID arg2 ;
    int arg3 ;
    char *arg4 = (char *) 0 ;
    iBase *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iCelPropertyClassList_FindByInterfaceAndTag",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (scfInterfaceID)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
        SWIG_arg_fail(4);SWIG_fail;
    }
    result = (iBase *)((iCelPropertyClassList const *)arg1)->FindByInterfaceAndTag(arg2,arg3,(char const *)arg4);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iBase, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iCelPropertyClassList(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iCelPropertyClassList",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iCelPropertyClassList_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iCelPropertyClassList, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iPcMechanicsSystem_SetDynamicSystem__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    iDynamicSystem *arg2 = (iDynamicSystem *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsSystem_SetDynamicSystem",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iDynamicSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetDynamicSystem(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_SetDynamicSystem__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsSystem_SetDynamicSystem",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->SetDynamicSystem((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_SetDynamicSystem(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[3];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcMechanicsSystem, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iDynamicSystem, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                return _wrap_iPcMechanicsSystem_SetDynamicSystem__SWIG_0(self,args);
            }
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcMechanicsSystem, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_AsCharPtr(argv[1], (char **)(0));
            if (_v) {
                return _wrap_iPcMechanicsSystem_SetDynamicSystem__SWIG_1(self,args);
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcMechanicsSystem_SetDynamicSystem'");
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_GetDynamicSystem(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    iDynamicSystem *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsSystem_GetDynamicSystem",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iDynamicSystem *)(arg1)->GetDynamicSystem();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iDynamicSystem, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_SetStepTime(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsSystem_SetStepTime",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetStepTime(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_GetStepTime(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsSystem_GetStepTime",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)((iPcMechanicsSystem const *)arg1)->GetStepTime();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_SetGravity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    csVector3 *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsSystem_SetGravity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetGravity((csVector3 const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_GetGravity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    csVector3 result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsSystem_GetGravity",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (arg1)->GetGravity();
    
    {
        csVector3 * resultptr;
        resultptr = new csVector3((csVector3 const &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csVector3, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_AddForceDuration(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    iPcMechanicsObject *arg2 = (iPcMechanicsObject *) 0 ;
    csVector3 *arg3 = 0 ;
    bool arg4 ;
    csVector3 *arg5 = 0 ;
    float arg6 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:iPcMechanicsSystem_AddForceDuration",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (bool)(SWIG_As_bool(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(5)) SWIG_fail;
        if (arg5 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        arg6 = (float)(SWIG_As_float(obj5)); 
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    (arg1)->AddForceDuration(arg2,(csVector3 const &)*arg3,arg4,(csVector3 const &)*arg5,arg6);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_AddForceFrame(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    iPcMechanicsObject *arg2 = (iPcMechanicsObject *) 0 ;
    csVector3 *arg3 = 0 ;
    bool arg4 ;
    csVector3 *arg5 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:iPcMechanicsSystem_AddForceFrame",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (bool)(SWIG_As_bool(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(5)) SWIG_fail;
        if (arg5 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    (arg1)->AddForceFrame(arg2,(csVector3 const &)*arg3,arg4,(csVector3 const &)*arg5);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_AddForceTagged(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    iPcMechanicsObject *arg2 = (iPcMechanicsObject *) 0 ;
    csVector3 *arg3 = 0 ;
    bool arg4 ;
    csVector3 *arg5 = 0 ;
    uint32 arg6 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:iPcMechanicsSystem_AddForceTagged",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (bool)(SWIG_As_bool(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(5)) SWIG_fail;
        if (arg5 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        uint32 * argp;
        SWIG_Python_ConvertPtr(obj5, (void **)&argp, SWIGTYPE_p_uint32_t, SWIG_POINTER_EXCEPTION);
        if (SWIG_arg_fail(6)) SWIG_fail;
        if (argp == NULL) {
            SWIG_null_ref("uint32");
        }
        if (SWIG_arg_fail(6)) SWIG_fail;
        arg6 = *argp;
    }
    (arg1)->AddForceTagged(arg2,(csVector3 const &)*arg3,arg4,(csVector3 const &)*arg5,arg6);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_RemoveForceTagged(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    iPcMechanicsObject *arg2 = (iPcMechanicsObject *) 0 ;
    uint32 arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcMechanicsSystem_RemoveForceTagged",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        uint32 * argp;
        SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_uint32_t, SWIG_POINTER_EXCEPTION);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (argp == NULL) {
            SWIG_null_ref("uint32");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
        arg3 = *argp;
    }
    (arg1)->RemoveForceTagged(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_ClearForces(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    iPcMechanicsObject *arg2 = (iPcMechanicsObject *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsSystem_ClearForces",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->ClearForces(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_ClearAllForces(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsSystem_ClearAllForces",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->ClearAllForces();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_CreateBody(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    SwigValueWrapper<csPtr<iRigidBody > > result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsSystem_CreateBody",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (arg1)->CreateBody();
    
    {
        csPtr<iRigidBody > * resultptr;
        resultptr = new csPtr<iRigidBody >((csPtr<iRigidBody > &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csPtrTiRigidBody_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_RemoveBody(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    iRigidBody *arg2 = (iRigidBody *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsSystem_RemoveBody",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iRigidBody, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->RemoveBody(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_AddBodyToGroup(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    iRigidBody *arg2 = (iRigidBody *) 0 ;
    char *arg3 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcMechanicsSystem_AddBodyToGroup",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iRigidBody, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    (arg1)->AddBodyToGroup(arg2,(char const *)arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_RemoveBodyFromGroup(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    iRigidBody *arg2 = (iRigidBody *) 0 ;
    char *arg3 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcMechanicsSystem_RemoveBodyFromGroup",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iRigidBody, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    (arg1)->RemoveBodyFromGroup(arg2,(char const *)arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_CreateJoint(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    iRigidBody *arg2 = (iRigidBody *) 0 ;
    iRigidBody *arg3 = (iRigidBody *) 0 ;
    iJoint *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcMechanicsSystem_CreateJoint",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iRigidBody, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_iRigidBody, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(3)) SWIG_fail;
    result = (iJoint *)(arg1)->CreateJoint(arg2,arg3);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iJoint, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_RemoveJoint(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    iJoint *arg2 = (iJoint *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsSystem_RemoveJoint",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iJoint, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->RemoveJoint(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_DisableStepFast(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsSystem_DisableStepFast",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->DisableStepFast();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_EnableStepFast(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsSystem_EnableStepFast",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->EnableStepFast();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsSystem_EnableQuickStep(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsSystem_EnableQuickStep",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->EnableQuickStep();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcMechanicsSystem(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsSystem *arg1 = (iPcMechanicsSystem *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcMechanicsSystem",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcMechanicsSystem_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcMechanicsSystem, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iPcMechanicsObject_SetMesh(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    iPcMesh *arg2 = (iPcMesh *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_SetMesh",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetMesh(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_GetMesh(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    iPcMesh *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsObject_GetMesh",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMesh *)(arg1)->GetMesh();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMesh, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_SetLight(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    iPcLight *arg2 = (iPcLight *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_SetLight",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcLight, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetLight(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_GetLight(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    iPcLight *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsObject_GetLight",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcLight *)(arg1)->GetLight();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcLight, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_SetCamera(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    iPcCamera *arg2 = (iPcCamera *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_SetCamera",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetCamera(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_GetCamera(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    iPcCamera *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsObject_GetCamera",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcCamera *)(arg1)->GetCamera();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcCamera, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_SetMechanicsSystem(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    iPcMechanicsSystem *arg2 = (iPcMechanicsSystem *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_SetMechanicsSystem",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMechanicsSystem, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetMechanicsSystem(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_GetMechanicsSystem(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    iPcMechanicsSystem *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsObject_GetMechanicsSystem",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMechanicsSystem *)(arg1)->GetMechanicsSystem();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsSystem, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_GetBody(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    iRigidBody *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsObject_GetBody",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iRigidBody *)(arg1)->GetBody();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iRigidBody, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_SetFriction(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_SetFriction",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetFriction(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_SetMass(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_SetMass",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetMass(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_SetElasticity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_SetElasticity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetElasticity(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_SetDensity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_SetDensity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetDensity(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_SetSoftness(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_SetSoftness",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetSoftness(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_SetLift(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    csVector3 *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_SetLift",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetLift((csVector3 const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_SetDrag(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_SetDrag",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetDrag(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_GetFriction(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsObject_GetFriction",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)(arg1)->GetFriction();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_GetMass(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsObject_GetMass",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)(arg1)->GetMass();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_GetElasticity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsObject_GetElasticity",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)(arg1)->GetElasticity();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_GetDensity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsObject_GetDensity",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)(arg1)->GetDensity();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_GetSoftness(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsObject_GetSoftness",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)(arg1)->GetSoftness();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_GetLift(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    csVector3 *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsObject_GetLift",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        csVector3 const &_result_ref = (arg1)->GetLift();
        result = (csVector3 *) &_result_ref;
    }
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_csVector3, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_GetDrag(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsObject_GetDrag",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)(arg1)->GetDrag();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_SetLinearVelocity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    csVector3 *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_SetLinearVelocity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetLinearVelocity((csVector3 const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_SetAngularVelocity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    csVector3 *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_SetAngularVelocity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetAngularVelocity((csVector3 const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_GetLinearVelocity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    csVector3 result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsObject_GetLinearVelocity",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (arg1)->GetLinearVelocity();
    
    {
        csVector3 * resultptr;
        resultptr = new csVector3((csVector3 const &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csVector3, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_GetAngularVelocity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    csVector3 result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsObject_GetAngularVelocity",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (arg1)->GetAngularVelocity();
    
    {
        csVector3 * resultptr;
        resultptr = new csVector3((csVector3 const &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csVector3, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_MakeStatic(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_MakeStatic",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->MakeStatic(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_IsStatic(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsObject_IsStatic",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iPcMechanicsObject const *)arg1)->IsStatic();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_AttachColliderSphere(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    float arg2 ;
    csVector3 *arg3 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcMechanicsObject_AttachColliderSphere",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->AttachColliderSphere(arg2,(csVector3 const &)*arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_AttachColliderCylinder(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    float arg2 ;
    float arg3 ;
    csOrthoTransform *arg4 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcMechanicsObject_AttachColliderCylinder",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_csOrthoTransform, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (arg4 == NULL) {
            SWIG_null_ref("csOrthoTransform");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    (arg1)->AttachColliderCylinder(arg2,arg3,(csOrthoTransform const &)*arg4);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_AttachColliderBox(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    csVector3 *arg2 = 0 ;
    csOrthoTransform *arg3 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcMechanicsObject_AttachColliderBox",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_csOrthoTransform, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csOrthoTransform");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->AttachColliderBox((csVector3 const &)*arg2,(csOrthoTransform const &)*arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_AttachColliderPlane(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    csPlane3 *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_AttachColliderPlane",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csPlane3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csPlane3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->AttachColliderPlane((csPlane3 const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_AttachColliderMesh(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsObject_AttachColliderMesh",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->AttachColliderMesh();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_AddForceOnce(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    csVector3 *arg2 = 0 ;
    bool arg3 ;
    csVector3 *arg4 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcMechanicsObject_AddForceOnce",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (bool)(SWIG_As_bool(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (arg4 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    (arg1)->AddForceOnce((csVector3 const &)*arg2,arg3,(csVector3 const &)*arg4);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_AddForceDuration(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    csVector3 *arg2 = 0 ;
    bool arg3 ;
    csVector3 *arg4 = 0 ;
    float arg5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:iPcMechanicsObject_AddForceDuration",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (bool)(SWIG_As_bool(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (arg4 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg5 = (float)(SWIG_As_float(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    (arg1)->AddForceDuration((csVector3 const &)*arg2,arg3,(csVector3 const &)*arg4,arg5);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_AddForceFrame(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    csVector3 *arg2 = 0 ;
    bool arg3 ;
    csVector3 *arg4 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcMechanicsObject_AddForceFrame",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (bool)(SWIG_As_bool(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (arg4 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    (arg1)->AddForceFrame((csVector3 const &)*arg2,arg3,(csVector3 const &)*arg4);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_AddForceTagged(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    csVector3 *arg2 = 0 ;
    bool arg3 ;
    csVector3 *arg4 = 0 ;
    uint32 result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcMechanicsObject_AddForceTagged",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (bool)(SWIG_As_bool(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (arg4 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    result = (arg1)->AddForceTagged((csVector3 const &)*arg2,arg3,(csVector3 const &)*arg4);
    
    {
        uint32 * resultptr;
        resultptr = new uint32((uint32 &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_uint32_t, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_RemoveForceTagged(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    uint32 arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_RemoveForceTagged",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        uint32 * argp;
        SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_uint32_t, SWIG_POINTER_EXCEPTION);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (argp == NULL) {
            SWIG_null_ref("uint32");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
        arg2 = *argp;
    }
    (arg1)->RemoveForceTagged(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_ClearForces(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsObject_ClearForces",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->ClearForces();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_AddToGroup(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_AddToGroup",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->AddToGroup((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_RemoveFromGroup(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_RemoveFromGroup",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->RemoveFromGroup((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_CreateJoint(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    iPcMechanicsObject *arg2 = (iPcMechanicsObject *) 0 ;
    iJoint *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_CreateJoint",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iJoint *)(arg1)->CreateJoint(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iJoint, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_LocalToWorld(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    csVector3 arg2 ;
    csVector3 result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_LocalToWorld",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        csVector3 * argp;
        SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (argp == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
        arg2 = *argp;
    }
    result = (arg1)->LocalToWorld(arg2);
    
    {
        csVector3 * resultptr;
        resultptr = new csVector3((csVector3 &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csVector3, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsObject_WorldToLocal(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    csVector3 arg2 ;
    csVector3 result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsObject_WorldToLocal",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        csVector3 * argp;
        SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (argp == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
        arg2 = *argp;
    }
    result = (arg1)->WorldToLocal(arg2);
    
    {
        csVector3 * resultptr;
        resultptr = new csVector3((csVector3 &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csVector3, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcMechanicsObject(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsObject *arg1 = (iPcMechanicsObject *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcMechanicsObject",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcMechanicsObject_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcMechanicsObject, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iPcMechanicsJoint_GetJoint(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsJoint *arg1 = (iPcMechanicsJoint *) 0 ;
    iJoint *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsJoint_GetJoint",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsJoint, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iJoint *)(arg1)->GetJoint();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iJoint, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcMechanicsJoint(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsJoint *arg1 = (iPcMechanicsJoint *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcMechanicsJoint",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsJoint, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcMechanicsJoint_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcMechanicsJoint, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateMechanicsSystem(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcMechanicsSystem *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateMechanicsSystem",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcMechanicsSystem *)celCreateMechanicsSystem(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsSystem, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetMechanicsSystem(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcMechanicsSystem *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetMechanicsSystem",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMechanicsSystem *)celGetMechanicsSystem(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsSystem, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcMechanicsSystem(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcMechanicsSystem *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcMechanicsSystem",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMechanicsSystem *)scfQuery_iPcMechanicsSystem(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsSystem, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQueryPC_iPcMechanicsSystem(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    iPcMechanicsSystem *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQueryPC_iPcMechanicsSystem",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMechanicsSystem *)scfQueryPC_iPcMechanicsSystem(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsSystem, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celCreateMechanicsObject(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcMechanicsObject *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateMechanicsObject",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcMechanicsObject *)celCreateMechanicsObject(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsObject, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetMechanicsObject(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcMechanicsObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetMechanicsObject",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMechanicsObject *)celGetMechanicsObject(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsObject, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcMechanicsObject(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcMechanicsObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcMechanicsObject",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMechanicsObject *)scfQuery_iPcMechanicsObject(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsObject, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQueryPC_iPcMechanicsObject(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    iPcMechanicsObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQueryPC_iPcMechanicsObject",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMechanicsObject *)scfQueryPC_iPcMechanicsObject(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsObject, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThruster_SetMechanicsObject(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThruster *arg1 = (iPcMechanicsThruster *) 0 ;
    iPcMechanicsObject *arg2 = (iPcMechanicsObject *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsThruster_SetMechanicsObject",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThruster, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetMechanicsObject(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThruster_GetMechanicsObject(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThruster *arg1 = (iPcMechanicsThruster *) 0 ;
    iPcMechanicsObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsThruster_GetMechanicsObject",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThruster, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMechanicsObject *)(arg1)->GetMechanicsObject();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsObject, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThruster_SetPosition(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThruster *arg1 = (iPcMechanicsThruster *) 0 ;
    csVector3 *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsThruster_SetPosition",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThruster, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetPosition((csVector3 const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThruster_GetPosition(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThruster *arg1 = (iPcMechanicsThruster *) 0 ;
    csVector3 *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsThruster_GetPosition",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThruster, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        csVector3 const &_result_ref = (arg1)->GetPosition();
        result = (csVector3 *) &_result_ref;
    }
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_csVector3, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThruster_SetOrientation(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThruster *arg1 = (iPcMechanicsThruster *) 0 ;
    csVector3 *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsThruster_SetOrientation",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThruster, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetOrientation((csVector3 const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThruster_GetOrientation(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThruster *arg1 = (iPcMechanicsThruster *) 0 ;
    csVector3 *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsThruster_GetOrientation",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThruster, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        csVector3 const &_result_ref = (arg1)->GetOrientation();
        result = (csVector3 *) &_result_ref;
    }
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_csVector3, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThruster_SetMaxThrust(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThruster *arg1 = (iPcMechanicsThruster *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsThruster_SetMaxThrust",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThruster, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetMaxThrust(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThruster_GetMaxThrust(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThruster *arg1 = (iPcMechanicsThruster *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsThruster_GetMaxThrust",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThruster, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)(arg1)->GetMaxThrust();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThruster_GetThrustForce(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThruster *arg1 = (iPcMechanicsThruster *) 0 ;
    float arg2 ;
    float result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsThruster_GetThrustForce",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThruster, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (float)(arg1)->GetThrustForce(arg2);
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThruster_AvailableThrust(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThruster *arg1 = (iPcMechanicsThruster *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsThruster_AvailableThrust",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThruster, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)(arg1)->AvailableThrust();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThruster_ThrustChange(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThruster *arg1 = (iPcMechanicsThruster *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsThruster_ThrustChange",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThruster, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->ThrustChange(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcMechanicsThruster(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThruster *arg1 = (iPcMechanicsThruster *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcMechanicsThruster",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThruster, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcMechanicsThruster_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcMechanicsThruster, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iPcMechanicsBalancedGroup_SetType(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsBalancedGroup *arg1 = (iPcMechanicsBalancedGroup *) 0 ;
    celAxisType arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsBalancedGroup_SetType",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsBalancedGroup, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (celAxisType)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetType((celAxisType )arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsBalancedGroup_GetType(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsBalancedGroup *arg1 = (iPcMechanicsBalancedGroup *) 0 ;
    celAxisType result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsBalancedGroup_GetType",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsBalancedGroup, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (celAxisType)(arg1)->GetType();
    
    resultobj = SWIG_From_int((result));
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsBalancedGroup_AddThruster(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsBalancedGroup *arg1 = (iPcMechanicsBalancedGroup *) 0 ;
    iPcMechanicsThruster *arg2 = (iPcMechanicsThruster *) 0 ;
    float arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcMechanicsBalancedGroup_AddThruster",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsBalancedGroup, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMechanicsThruster, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->AddThruster(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsBalancedGroup_RemoveThruster(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsBalancedGroup *arg1 = (iPcMechanicsBalancedGroup *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsBalancedGroup_RemoveThruster",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsBalancedGroup, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->RemoveThruster((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsBalancedGroup_GetThruster(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsBalancedGroup *arg1 = (iPcMechanicsBalancedGroup *) 0 ;
    char *arg2 = (char *) 0 ;
    iPcMechanicsThruster *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsBalancedGroup_GetThruster",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsBalancedGroup, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iPcMechanicsThruster *)(arg1)->GetThruster((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsThruster, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsBalancedGroup_AvailableThrust(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsBalancedGroup *arg1 = (iPcMechanicsBalancedGroup *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsBalancedGroup_AvailableThrust",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsBalancedGroup, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)(arg1)->AvailableThrust();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsBalancedGroup_AvailableThrustForce(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsBalancedGroup *arg1 = (iPcMechanicsBalancedGroup *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsBalancedGroup_AvailableThrustForce",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsBalancedGroup, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)(arg1)->AvailableThrustForce();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsBalancedGroup_ChangeThrust(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsBalancedGroup *arg1 = (iPcMechanicsBalancedGroup *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsBalancedGroup_ChangeThrust",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsBalancedGroup, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->ChangeThrust(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcMechanicsBalancedGroup(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsBalancedGroup *arg1 = (iPcMechanicsBalancedGroup *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcMechanicsBalancedGroup",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsBalancedGroup, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcMechanicsBalancedGroup_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcMechanicsBalancedGroup, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iPcMechanicsThrusterController_SetMechanicsObject(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThrusterController *arg1 = (iPcMechanicsThrusterController *) 0 ;
    iPcMechanicsObject *arg2 = (iPcMechanicsObject *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsThrusterController_SetMechanicsObject",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThrusterController, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMechanicsObject, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetMechanicsObject(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThrusterController_GetMechanicsObject(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThrusterController *arg1 = (iPcMechanicsThrusterController *) 0 ;
    iPcMechanicsObject *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMechanicsThrusterController_GetMechanicsObject",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThrusterController, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMechanicsObject *)(arg1)->GetMechanicsObject();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsObject, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThrusterController_AddAxis(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThrusterController *arg1 = (iPcMechanicsThrusterController *) 0 ;
    char *arg2 = (char *) 0 ;
    celAxisType arg3 ;
    csVector3 arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcMechanicsThrusterController_AddAxis",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThrusterController, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    {
        arg3 = (celAxisType)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        csVector3 * argp;
        SWIG_Python_ConvertPtr(obj3, (void **)&argp, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (argp == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
        arg4 = *argp;
    }
    (arg1)->AddAxis((char const *)arg2,(celAxisType )arg3,arg4);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThrusterController_GetAxis(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThrusterController *arg1 = (iPcMechanicsThrusterController *) 0 ;
    char *arg2 = (char *) 0 ;
    csVector3 result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsThrusterController_GetAxis",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThrusterController, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (arg1)->GetAxis((char const *)arg2);
    
    {
        csVector3 * resultptr;
        resultptr = new csVector3((csVector3 const &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csVector3, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThrusterController_GetAxisType(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThrusterController *arg1 = (iPcMechanicsThrusterController *) 0 ;
    char *arg2 = (char *) 0 ;
    celAxisType result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsThrusterController_GetAxisType",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThrusterController, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (celAxisType)(arg1)->GetAxisType((char const *)arg2);
    
    resultobj = SWIG_From_int((result));
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThrusterController_GetAxisVelocity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThrusterController *arg1 = (iPcMechanicsThrusterController *) 0 ;
    char *arg2 = (char *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsThrusterController_GetAxisVelocity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThrusterController, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (float)(arg1)->GetAxisVelocity((char const *)arg2);
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThrusterController_GetAxisMaxForce(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThrusterController *arg1 = (iPcMechanicsThrusterController *) 0 ;
    char *arg2 = (char *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsThrusterController_GetAxisMaxForce",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThrusterController, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (float)(arg1)->GetAxisMaxForce((char const *)arg2);
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThrusterController_GetAxisMaxThrust(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThrusterController *arg1 = (iPcMechanicsThrusterController *) 0 ;
    char *arg2 = (char *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsThrusterController_GetAxisMaxThrust",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThrusterController, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (float)(arg1)->GetAxisMaxThrust((char const *)arg2);
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThrusterController_AddBalancedGroup(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThrusterController *arg1 = (iPcMechanicsThrusterController *) 0 ;
    iPcMechanicsBalancedGroup *arg2 = (iPcMechanicsBalancedGroup *) 0 ;
    char *arg3 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcMechanicsThrusterController_AddBalancedGroup",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThrusterController, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMechanicsBalancedGroup, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    (arg1)->AddBalancedGroup(arg2,(char const *)arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThrusterController_RemoveBalancedGroup(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThrusterController *arg1 = (iPcMechanicsThrusterController *) 0 ;
    char *arg2 = (char *) 0 ;
    char *arg3 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcMechanicsThrusterController_RemoveBalancedGroup",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThrusterController, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    (arg1)->RemoveBalancedGroup((char const *)arg2,(char const *)arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThrusterController_ApplyThrust(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThrusterController *arg1 = (iPcMechanicsThrusterController *) 0 ;
    float arg2 ;
    char *arg3 = (char *) 0 ;
    uint32 *arg4 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcMechanicsThrusterController_ApplyThrust",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThrusterController, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_uint32_t, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (arg4 == NULL) {
            SWIG_null_ref("uint32");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    (arg1)->ApplyThrust(arg2,(char const *)arg3,*arg4);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMechanicsThrusterController_CancelThrust(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThrusterController *arg1 = (iPcMechanicsThrusterController *) 0 ;
    uint32 arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMechanicsThrusterController_CancelThrust",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThrusterController, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        uint32 * argp;
        SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_uint32_t, SWIG_POINTER_EXCEPTION);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (argp == NULL) {
            SWIG_null_ref("uint32");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
        arg2 = *argp;
    }
    (arg1)->CancelThrust(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcMechanicsThrusterController(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMechanicsThrusterController *arg1 = (iPcMechanicsThrusterController *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcMechanicsThrusterController",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMechanicsThrusterController, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcMechanicsThrusterController_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcMechanicsThrusterController, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateMechanicsThrusterReactionary(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcMechanicsThruster *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateMechanicsThrusterReactionary",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcMechanicsThruster *)celCreateMechanicsThrusterReactionary(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsThruster, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetMechanicsThrusterReactionary(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcMechanicsThruster *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetMechanicsThrusterReactionary",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMechanicsThruster *)celGetMechanicsThrusterReactionary(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsThruster, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcMechanicsThruster(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcMechanicsThruster *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcMechanicsThruster",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMechanicsThruster *)scfQuery_iPcMechanicsThruster(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsThruster, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQueryPC_iPcMechanicsThruster(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    iPcMechanicsThruster *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQueryPC_iPcMechanicsThruster",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMechanicsThruster *)scfQueryPC_iPcMechanicsThruster(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsThruster, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celCreateMechanicsBalancedGroup(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcMechanicsBalancedGroup *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateMechanicsBalancedGroup",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcMechanicsBalancedGroup *)celCreateMechanicsBalancedGroup(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsBalancedGroup, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetMechanicsBalancedGroup(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcMechanicsBalancedGroup *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetMechanicsBalancedGroup",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMechanicsBalancedGroup *)celGetMechanicsBalancedGroup(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsBalancedGroup, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcMechanicsBalancedGroup(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcMechanicsBalancedGroup *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcMechanicsBalancedGroup",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMechanicsBalancedGroup *)scfQuery_iPcMechanicsBalancedGroup(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsBalancedGroup, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQueryPC_iPcMechanicsBalancedGroup(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    iPcMechanicsBalancedGroup *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQueryPC_iPcMechanicsBalancedGroup",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMechanicsBalancedGroup *)scfQueryPC_iPcMechanicsBalancedGroup(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsBalancedGroup, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celCreateMechanicsThrusterController(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcMechanicsThrusterController *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateMechanicsThrusterController",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcMechanicsThrusterController *)celCreateMechanicsThrusterController(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsThrusterController, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetMechanicsThrusterController(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcMechanicsThrusterController *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetMechanicsThrusterController",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMechanicsThrusterController *)celGetMechanicsThrusterController(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsThrusterController, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcMechanicsThrusterController(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcMechanicsThrusterController *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcMechanicsThrusterController",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMechanicsThrusterController *)scfQuery_iPcMechanicsThrusterController(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsThrusterController, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQueryPC_iPcMechanicsThrusterController(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    iPcMechanicsThrusterController *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQueryPC_iPcMechanicsThrusterController",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMechanicsThrusterController *)scfQueryPC_iPcMechanicsThrusterController(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMechanicsThrusterController, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardLayer_GetOffset(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardLayer *arg1 = (iBillboardLayer *) 0 ;
    int *arg2 = 0 ;
    int *arg3 = 0 ;
    int temp2 ;
    int res2 = 0 ;
    int temp3 ;
    int res3 = 0 ;
    PyObject * obj0 = 0 ;
    
    arg2 = &temp2; res2 = SWIG_NEWOBJ;
    arg3 = &temp3; res3 = SWIG_NEWOBJ;
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboardLayer_GetOffset",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    ((iBillboardLayer const *)arg1)->GetOffset(*arg2,*arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
    SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
    resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
    SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardLayer_SetOffset(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardLayer *arg1 = (iBillboardLayer *) 0 ;
    int arg2 ;
    int arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iBillboardLayer_SetOffset",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->SetOffset(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardLayer_Move(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardLayer *arg1 = (iBillboardLayer *) 0 ;
    int arg2 ;
    int arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iBillboardLayer_Move",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->Move(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardLayer_GetName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardLayer *arg1 = (iBillboardLayer *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboardLayer_GetName",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)((iBillboardLayer const *)arg1)->GetName();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iBillboardLayer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardLayer *arg1 = (iBillboardLayer *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iBillboardLayer",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iBillboardLayer_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iBillboardLayer, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iBillboardEventHandler_Select(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardEventHandler *arg1 = (iBillboardEventHandler *) 0 ;
    iBillboard *arg2 = (iBillboard *) 0 ;
    int arg3 ;
    int arg4 ;
    int arg5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:iBillboardEventHandler_Select",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardEventHandler, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (int)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg5 = (int)(SWIG_As_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    (arg1)->Select(arg2,arg3,arg4,arg5);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardEventHandler_MouseMove(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardEventHandler *arg1 = (iBillboardEventHandler *) 0 ;
    iBillboard *arg2 = (iBillboard *) 0 ;
    int arg3 ;
    int arg4 ;
    int arg5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:iBillboardEventHandler_MouseMove",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardEventHandler, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (int)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg5 = (int)(SWIG_As_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    (arg1)->MouseMove(arg2,arg3,arg4,arg5);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardEventHandler_Unselect(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardEventHandler *arg1 = (iBillboardEventHandler *) 0 ;
    iBillboard *arg2 = (iBillboard *) 0 ;
    int arg3 ;
    int arg4 ;
    int arg5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:iBillboardEventHandler_Unselect",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardEventHandler, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (int)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg5 = (int)(SWIG_As_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    (arg1)->Unselect(arg2,arg3,arg4,arg5);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardEventHandler_DoubleClick(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardEventHandler *arg1 = (iBillboardEventHandler *) 0 ;
    iBillboard *arg2 = (iBillboard *) 0 ;
    int arg3 ;
    int arg4 ;
    int arg5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:iBillboardEventHandler_DoubleClick",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardEventHandler, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (int)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg5 = (int)(SWIG_As_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    (arg1)->DoubleClick(arg2,arg3,arg4,arg5);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iBillboardEventHandler(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardEventHandler *arg1 = (iBillboardEventHandler *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iBillboardEventHandler",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardEventHandler, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iBillboardEventHandler_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iBillboardEventHandler, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iBillboard_GetName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboard_GetName",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)((iBillboard const *)arg1)->GetName();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_GetFlags(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    csFlags *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboard_GetFlags",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        csFlags &_result_ref = (arg1)->GetFlags();
        result = (csFlags *) &_result_ref;
    }
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_csFlags, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_SetMaterialName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    char *arg2 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboard_SetMaterialName",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (bool)(arg1)->SetMaterialName((char const *)arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_SetMaterialNameFast(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    char *arg2 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboard_SetMaterialNameFast",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (bool)(arg1)->SetMaterialNameFast((char const *)arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_GetMaterialName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboard_GetMaterialName",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)(arg1)->GetMaterialName();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_SetSize(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    int arg2 ;
    int arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iBillboard_SetSize",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->SetSize(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_GetSize(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    int *arg2 = 0 ;
    int *arg3 = 0 ;
    int temp2 ;
    int res2 = 0 ;
    int temp3 ;
    int res3 = 0 ;
    PyObject * obj0 = 0 ;
    
    arg2 = &temp2; res2 = SWIG_NEWOBJ;
    arg3 = &temp3; res3 = SWIG_NEWOBJ;
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboard_GetSize",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->GetSize(*arg2,*arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
    SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
    resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
    SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_GetImageSize(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    int *arg2 = 0 ;
    int *arg3 = 0 ;
    int temp2 ;
    int res2 = 0 ;
    int temp3 ;
    int res3 = 0 ;
    PyObject * obj0 = 0 ;
    
    arg2 = &temp2; res2 = SWIG_NEWOBJ;
    arg3 = &temp3; res3 = SWIG_NEWOBJ;
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboard_GetImageSize",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->GetImageSize(*arg2,*arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
    SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
    resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
    SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_SetPosition(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    int arg2 ;
    int arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iBillboard_SetPosition",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->SetPosition(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_MoveToPosition(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    csTicks arg2 ;
    int arg3 ;
    int arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iBillboard_MoveToPosition",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csTicks)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (int)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    (arg1)->MoveToPosition(arg2,arg3,arg4);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_GetPosition(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    int *arg2 = 0 ;
    int *arg3 = 0 ;
    int temp2 ;
    int res2 = 0 ;
    int temp3 ;
    int res3 = 0 ;
    PyObject * obj0 = 0 ;
    
    arg2 = &temp2; res2 = SWIG_NEWOBJ;
    arg3 = &temp3; res3 = SWIG_NEWOBJ;
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboard_GetPosition",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    ((iBillboard const *)arg1)->GetPosition(*arg2,*arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
    SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
    resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
    SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_Move(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    int arg2 ;
    int arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iBillboard_Move",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->Move(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_StackTop(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboard_StackTop",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->StackTop();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_StackBottom(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboard_StackBottom",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->StackBottom();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_StackUp(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboard_StackUp",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->StackUp();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_StackDown(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboard_StackDown",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->StackDown();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_SetUVTopLeft(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    csVector2 *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboard_SetUVTopLeft",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector2, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector2");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetUVTopLeft((csVector2 const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_GetUVTopLeft(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    csVector2 *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboard_GetUVTopLeft",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        csVector2 const &_result_ref = ((iBillboard const *)arg1)->GetUVTopLeft();
        result = (csVector2 *) &_result_ref;
    }
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_csVector2, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_SetUVBottomRight(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    csVector2 *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboard_SetUVBottomRight",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector2, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector2");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetUVBottomRight((csVector2 const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_GetUVBottomRight(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    csVector2 *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboard_GetUVBottomRight",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        csVector2 const &_result_ref = ((iBillboard const *)arg1)->GetUVBottomRight();
        result = (csVector2 *) &_result_ref;
    }
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_csVector2, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_SetColor(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    csColor *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboard_SetColor",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csColor, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csColor");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetColor((csColor const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_GetColor(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    csColor *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboard_GetColor",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        csColor const &_result_ref = ((iBillboard const *)arg1)->GetColor();
        result = (csColor *) &_result_ref;
    }
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_csColor, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_SetLayer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    iBillboardLayer *arg2 = (iBillboardLayer *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboard_SetLayer",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iBillboardLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetLayer(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_GetLayer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    iBillboardLayer *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboard_GetLayer",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iBillboardLayer *)((iBillboard const *)arg1)->GetLayer();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iBillboardLayer, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_AddEventHandler(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    iBillboardEventHandler *arg2 = (iBillboardEventHandler *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboard_AddEventHandler",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iBillboardEventHandler, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->AddEventHandler(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_RemoveEventHandler(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    iBillboardEventHandler *arg2 = (iBillboardEventHandler *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboard_RemoveEventHandler",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iBillboardEventHandler, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->RemoveEventHandler(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_SetText(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboard_SetText",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->SetText((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_GetText(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboard_GetText",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)((iBillboard const *)arg1)->GetText();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_SetTextOffset(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    int arg2 ;
    int arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iBillboard_SetTextOffset",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->SetTextOffset(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_SetTextFont(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    char *arg2 = (char *) 0 ;
    float arg3 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iBillboard_SetTextFont",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (bool)(arg1)->SetTextFont((char const *)arg2,arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_SetTextFgColor(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    csColor *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboard_SetTextFgColor",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csColor, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csColor");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetTextFgColor((csColor const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_ClearTextFgColor(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboard_ClearTextFgColor",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->ClearTextFgColor();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_SetTextBgColor(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    csColor *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboard_SetTextBgColor",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csColor, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csColor");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetTextBgColor((csColor const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_SetTextBgTransparent(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboard_SetTextBgTransparent",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->SetTextBgTransparent();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboard_ClearTextBgColor(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboard_ClearTextBgColor",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->ClearTextBgColor();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iBillboard(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboard *arg1 = (iBillboard *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iBillboard",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iBillboard_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iBillboard, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iBillboardManager_ScreenToBillboardX(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    int arg2 ;
    int result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboardManager_ScreenToBillboardX",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (int)((iBillboardManager const *)arg1)->ScreenToBillboardX(arg2);
    
    {
        resultobj = SWIG_From_int((int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_ScreenToBillboardY(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    int arg2 ;
    int result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboardManager_ScreenToBillboardY",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (int)((iBillboardManager const *)arg1)->ScreenToBillboardY(arg2);
    
    {
        resultobj = SWIG_From_int((int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_BillboardToScreenX(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    int arg2 ;
    int result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboardManager_BillboardToScreenX",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (int)((iBillboardManager const *)arg1)->BillboardToScreenX(arg2);
    
    {
        resultobj = SWIG_From_int((int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_BillboardToScreenY(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    int arg2 ;
    int result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboardManager_BillboardToScreenY",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (int)((iBillboardManager const *)arg1)->BillboardToScreenY(arg2);
    
    {
        resultobj = SWIG_From_int((int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_CreateBillboard(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    char *arg2 = (char *) 0 ;
    iBillboard *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboardManager_CreateBillboard",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iBillboard *)(arg1)->CreateBillboard((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iBillboard, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_FindBillboard(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    char *arg2 = (char *) 0 ;
    iBillboard *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboardManager_FindBillboard",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iBillboard *)((iBillboardManager const *)arg1)->FindBillboard((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iBillboard, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_RemoveBillboard(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    iBillboard *arg2 = (iBillboard *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboardManager_RemoveBillboard",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->RemoveBillboard(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_GetBillboardCount(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    size_t result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboardManager_GetBillboardCount",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = ((iBillboardManager const *)arg1)->GetBillboardCount();
    
    {
        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_GetBillboard(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    size_t arg2 ;
    iBillboard *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboardManager_GetBillboard",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (iBillboard *)((iBillboardManager const *)arg1)->GetBillboard(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iBillboard, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_CreateBillboardLayer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    char *arg2 = (char *) 0 ;
    iBillboardLayer *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboardManager_CreateBillboardLayer",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iBillboardLayer *)(arg1)->CreateBillboardLayer((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iBillboardLayer, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_FindBillboardLayer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    char *arg2 = (char *) 0 ;
    iBillboardLayer *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboardManager_FindBillboardLayer",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iBillboardLayer *)((iBillboardManager const *)arg1)->FindBillboardLayer((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iBillboardLayer, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_RemoveBillboardLayer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    iBillboardLayer *arg2 = (iBillboardLayer *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboardManager_RemoveBillboardLayer",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iBillboardLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->RemoveBillboardLayer(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_GetBillboardLayerCount(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    size_t result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboardManager_GetBillboardLayerCount",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = ((iBillboardManager const *)arg1)->GetBillboardLayerCount();
    
    {
        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_GetBillboardLayer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    size_t arg2 ;
    iBillboardLayer *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboardManager_GetBillboardLayer",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (iBillboardLayer *)((iBillboardManager const *)arg1)->GetBillboardLayer(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iBillboardLayer, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_RemoveAll(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboardManager_RemoveAll",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->RemoveAll();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_SetFlags(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    uint32 arg2 ;
    uint32 arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iBillboardManager_SetFlags",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        uint32 * argp;
        SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_uint32_t, SWIG_POINTER_EXCEPTION);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (argp == NULL) {
            SWIG_null_ref("uint32");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
        arg2 = *argp;
    }
    {
        uint32 * argp;
        SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_uint32_t, SWIG_POINTER_EXCEPTION);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (argp == NULL) {
            SWIG_null_ref("uint32");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
        arg3 = *argp;
    }
    (arg1)->SetFlags(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_StackTop(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    iBillboard *arg2 = (iBillboard *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboardManager_StackTop",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->StackTop(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_StackBottom(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    iBillboard *arg2 = (iBillboard *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboardManager_StackBottom",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->StackBottom(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_StackUp(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    iBillboard *arg2 = (iBillboard *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboardManager_StackUp",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->StackUp(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_StackDown(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    iBillboard *arg2 = (iBillboard *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboardManager_StackDown",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->StackDown(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_StackBefore(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    iBillboard *arg2 = (iBillboard *) 0 ;
    iBillboard *arg3 = (iBillboard *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iBillboardManager_StackBefore",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(3)) SWIG_fail;
    (arg1)->StackBefore(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_StackAfter(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    iBillboard *arg2 = (iBillboard *) 0 ;
    iBillboard *arg3 = (iBillboard *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iBillboardManager_StackAfter",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(3)) SWIG_fail;
    (arg1)->StackAfter(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_TestCollision(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    iBillboard *arg2 = (iBillboard *) 0 ;
    iBillboard *arg3 = (iBillboard *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iBillboardManager_TestCollision",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_iBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(3)) SWIG_fail;
    result = (bool)(arg1)->TestCollision(arg2,arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_SetDefaultTextFont(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    char *arg2 = (char *) 0 ;
    float arg3 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iBillboardManager_SetDefaultTextFont",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (bool)(arg1)->SetDefaultTextFont((char const *)arg2,arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_SetDefaultTextFgColor(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    csColor *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboardManager_SetDefaultTextFgColor",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csColor, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csColor");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetDefaultTextFgColor((csColor const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_SetDefaultTextBgColor(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    csColor *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iBillboardManager_SetDefaultTextBgColor",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csColor, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csColor");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetDefaultTextBgColor((csColor const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iBillboardManager_SetDefaultTextBgTransparent(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iBillboardManager_SetDefaultTextBgTransparent",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->SetDefaultTextBgTransparent();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iBillboardManager(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iBillboardManager *arg1 = (iBillboardManager *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iBillboardManager",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iBillboardManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iBillboardManager_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iBillboardManager, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iPcBillboard_SetBillboardName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcBillboard *arg1 = (iPcBillboard *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcBillboard_SetBillboardName",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->SetBillboardName((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcBillboard_GetBillboardName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcBillboard *arg1 = (iPcBillboard *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcBillboard_GetBillboardName",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)(arg1)->GetBillboardName();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcBillboard_GetBillboard(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcBillboard *arg1 = (iPcBillboard *) 0 ;
    iBillboard *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcBillboard_GetBillboard",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iBillboard *)(arg1)->GetBillboard();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iBillboard, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcBillboard_EnableEvents(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcBillboard *arg1 = (iPcBillboard *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcBillboard_EnableEvents",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->EnableEvents(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcBillboard_AreEventsEnabled(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcBillboard *arg1 = (iPcBillboard *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcBillboard_AreEventsEnabled",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iPcBillboard const *)arg1)->AreEventsEnabled();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcBillboard(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcBillboard *arg1 = (iPcBillboard *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcBillboard",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcBillboard, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcBillboard_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcBillboard, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateBillboard(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcBillboard *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateBillboard",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcBillboard *)celCreateBillboard(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcBillboard, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetBillboard(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcBillboard *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetBillboard",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcBillboard *)celGetBillboard(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcBillboard, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcBillboard(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcBillboard *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcBillboard",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcBillboard *)scfQuery_iPcBillboard(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcBillboard, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQueryPC_iPcBillboard(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    iPcBillboard *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQueryPC_iPcBillboard",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcBillboard *)scfQueryPC_iPcBillboard(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcBillboard, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcRegion_SetWorldFile(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcRegion *arg1 = (iPcRegion *) 0 ;
    char *arg2 = (char *) 0 ;
    char *arg3 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcRegion_SetWorldFile",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    (arg1)->SetWorldFile((char const *)arg2,(char const *)arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcRegion_GetWorldDir(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcRegion *arg1 = (iPcRegion *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcRegion_GetWorldDir",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)((iPcRegion const *)arg1)->GetWorldDir();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcRegion_GetWorldFile(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcRegion *arg1 = (iPcRegion *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcRegion_GetWorldFile",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)((iPcRegion const *)arg1)->GetWorldFile();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcRegion_SetRegionName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcRegion *arg1 = (iPcRegion *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcRegion_SetRegionName",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->SetRegionName((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcRegion_GetRegionName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcRegion *arg1 = (iPcRegion *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcRegion_GetRegionName",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)((iPcRegion const *)arg1)->GetRegionName();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcRegion_CreateEmptySector(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcRegion *arg1 = (iPcRegion *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcRegion_CreateEmptySector",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->CreateEmptySector((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcRegion_Load(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcRegion *arg1 = (iPcRegion *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcRegion_Load",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)(arg1)->Load();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcRegion_Unload(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcRegion *arg1 = (iPcRegion *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcRegion_Unload",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->Unload();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcRegion_FindSector(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcRegion *arg1 = (iPcRegion *) 0 ;
    char *arg2 = (char *) 0 ;
    iSector *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcRegion_FindSector",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iSector *)(arg1)->FindSector((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iSector, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcRegion_GetStartSector__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcRegion *arg1 = (iPcRegion *) 0 ;
    char *arg2 = (char *) 0 ;
    iSector *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcRegion_GetStartSector",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iSector *)(arg1)->GetStartSector((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iSector, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcRegion_GetStartSector__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcRegion *arg1 = (iPcRegion *) 0 ;
    iSector *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcRegion_GetStartSector",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iSector *)(arg1)->GetStartSector();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iSector, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcRegion_GetStartSector(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[3];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcRegion, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            return _wrap_iPcRegion_GetStartSector__SWIG_1(self,args);
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcRegion, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_AsCharPtr(argv[1], (char **)(0));
            if (_v) {
                return _wrap_iPcRegion_GetStartSector__SWIG_0(self,args);
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcRegion_GetStartSector'");
    return NULL;
}


static PyObject *_wrap_iPcRegion_GetStartPosition__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcRegion *arg1 = (iPcRegion *) 0 ;
    char *arg2 = (char *) 0 ;
    csVector3 result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcRegion_GetStartPosition",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (arg1)->GetStartPosition((char const *)arg2);
    
    {
        csVector3 * resultptr;
        resultptr = new csVector3((csVector3 &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csVector3, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcRegion_GetStartPosition__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcRegion *arg1 = (iPcRegion *) 0 ;
    csVector3 result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcRegion_GetStartPosition",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (arg1)->GetStartPosition();
    
    {
        csVector3 * resultptr;
        resultptr = new csVector3((csVector3 &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csVector3, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcRegion_GetStartPosition(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[3];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcRegion, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            return _wrap_iPcRegion_GetStartPosition__SWIG_1(self,args);
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcRegion, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_AsCharPtr(argv[1], (char **)(0));
            if (_v) {
                return _wrap_iPcRegion_GetStartPosition__SWIG_0(self,args);
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcRegion_GetStartPosition'");
    return NULL;
}


static PyObject *_wrap_iPcRegion_PointCamera__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcRegion *arg1 = (iPcRegion *) 0 ;
    iPcCamera *arg2 = (iPcCamera *) 0 ;
    char *arg3 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcRegion_PointCamera",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    (arg1)->PointCamera(arg2,(char const *)arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcRegion_PointCamera__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcRegion *arg1 = (iPcRegion *) 0 ;
    iPcCamera *arg2 = (iPcCamera *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcRegion_PointCamera",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->PointCamera(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcRegion_PointCamera(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[4];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcRegion, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iPcCamera, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                return _wrap_iPcRegion_PointCamera__SWIG_1(self,args);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcRegion, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iPcCamera, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                _v = SWIG_AsCharPtr(argv[2], (char **)(0));
                if (_v) {
                    return _wrap_iPcRegion_PointCamera__SWIG_0(self,args);
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcRegion_PointCamera'");
    return NULL;
}


static PyObject *_wrap_iPcRegion_GetRegion(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcRegion *arg1 = (iPcRegion *) 0 ;
    iRegion *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcRegion_GetRegion",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iRegion *)(arg1)->GetRegion();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iRegion, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcRegion_LoadWorld(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcRegion *arg1 = (iPcRegion *) 0 ;
    char *arg2 = (char *) 0 ;
    char *arg3 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcRegion_LoadWorld",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    result = (bool)iPcRegion_LoadWorld(arg1,(char const *)arg2,(char const *)arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcRegion(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcRegion *arg1 = (iPcRegion *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcRegion",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcRegion_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcRegion, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateRegion(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    char *arg3 = (char *) 0 ;
    iPcRegion *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:celCreateRegion",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    result = (iPcRegion *)celCreateRegion(arg1,arg2,(char const *)arg3);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcRegion, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_Region(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcRegion *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:Region",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcRegion *)Region(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcRegion, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcRegion(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcRegion *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcRegion",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcRegion *)scfQuery_iPcRegion(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcRegion, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQueryPC_iPcRegion(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClassList *arg1 = (iCelPropertyClassList *) 0 ;
    iPcRegion *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQueryPC_iPcRegion",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClassList, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcRegion *)scfQueryPC_iPcRegion(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcRegion, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelMapFile_SetPath(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelMapFile *arg1 = (iCelMapFile *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelMapFile_SetPath",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelMapFile, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->SetPath((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelMapFile_SetFile(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelMapFile *arg1 = (iCelMapFile *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelMapFile_SetFile",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelMapFile, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->SetFile((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelMapFile_GetPath(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelMapFile *arg1 = (iCelMapFile *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelMapFile_GetPath",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelMapFile, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)((iCelMapFile const *)arg1)->GetPath();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelMapFile_GetFile(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelMapFile *arg1 = (iCelMapFile *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelMapFile_GetFile",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelMapFile, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)((iCelMapFile const *)arg1)->GetFile();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelMapFile_SetSectorName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelMapFile *arg1 = (iCelMapFile *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelMapFile_SetSectorName",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelMapFile, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->SetSectorName((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelMapFile_GetSectorName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelMapFile *arg1 = (iCelMapFile *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelMapFile_GetSectorName",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelMapFile, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)((iCelMapFile const *)arg1)->GetSectorName();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iCelMapFile(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelMapFile *arg1 = (iCelMapFile *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iCelMapFile",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelMapFile, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iCelMapFile_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iCelMapFile, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iCelRegion_GetName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelRegion *arg1 = (iCelRegion *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelRegion_GetName",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)((iCelRegion const *)arg1)->GetName();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelRegion_SetCachePath(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelRegion *arg1 = (iCelRegion *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelRegion_SetCachePath",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->SetCachePath((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelRegion_GetCachePath(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelRegion *arg1 = (iCelRegion *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelRegion_GetCachePath",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)((iCelRegion const *)arg1)->GetCachePath();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelRegion_CreateMapFile(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelRegion *arg1 = (iCelRegion *) 0 ;
    iCelMapFile *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelRegion_CreateMapFile",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iCelMapFile *)(arg1)->CreateMapFile();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelMapFile, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelRegion_GetMapFileCount(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelRegion *arg1 = (iCelRegion *) 0 ;
    size_t result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelRegion_GetMapFileCount",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = ((iCelRegion const *)arg1)->GetMapFileCount();
    
    {
        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelRegion_GetMapFile(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelRegion *arg1 = (iCelRegion *) 0 ;
    int arg2 ;
    iCelMapFile *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelRegion_GetMapFile",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (iCelMapFile *)((iCelRegion const *)arg1)->GetMapFile(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelMapFile, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelRegion_RemoveMapFile(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelRegion *arg1 = (iCelRegion *) 0 ;
    iCelMapFile *arg2 = (iCelMapFile *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelRegion_RemoveMapFile",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelMapFile, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->RemoveMapFile(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelRegion_RemoveAllMapFiles(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelRegion *arg1 = (iCelRegion *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelRegion_RemoveAllMapFiles",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->RemoveAllMapFiles();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelRegion_AssociateEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelRegion *arg1 = (iCelRegion *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelRegion_AssociateEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->AssociateEntity(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelRegion_DissociateEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelRegion *arg1 = (iCelRegion *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelRegion_DissociateEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->DissociateEntity(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iCelRegion(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelRegion *arg1 = (iCelRegion *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iCelRegion",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iCelRegion_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iCelRegion, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iCelZone_GetName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelZone *arg1 = (iCelZone *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelZone_GetName",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelZone, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)((iCelZone const *)arg1)->GetName();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelZone_LinkRegion(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelZone *arg1 = (iCelZone *) 0 ;
    iCelRegion *arg2 = (iCelRegion *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelZone_LinkRegion",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelZone, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->LinkRegion(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelZone_GetRegionCount(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelZone *arg1 = (iCelZone *) 0 ;
    size_t result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelZone_GetRegionCount",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelZone, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = ((iCelZone const *)arg1)->GetRegionCount();
    
    {
        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelZone_GetRegion(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelZone *arg1 = (iCelZone *) 0 ;
    size_t arg2 ;
    iCelRegion *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelZone_GetRegion",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelZone, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (iCelRegion *)((iCelZone const *)arg1)->GetRegion(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelRegion, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelZone_FindRegion(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelZone *arg1 = (iCelZone *) 0 ;
    char *arg2 = (char *) 0 ;
    iCelRegion *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelZone_FindRegion",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelZone, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iCelRegion *)((iCelZone const *)arg1)->FindRegion((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelRegion, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelZone_UnlinkRegion(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelZone *arg1 = (iCelZone *) 0 ;
    iCelRegion *arg2 = (iCelRegion *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelZone_UnlinkRegion",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelZone, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->UnlinkRegion(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelZone_UnlinkAllRegions(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelZone *arg1 = (iCelZone *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelZone_UnlinkAllRegions",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelZone, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->UnlinkAllRegions();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iCelZone(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelZone *arg1 = (iCelZone *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iCelZone",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelZone, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iCelZone_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iCelZone, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iPcZoneManager_EnableColliderWrappers(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcZoneManager_EnableColliderWrappers",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->EnableColliderWrappers(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_IsColliderWrappers(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcZoneManager_IsColliderWrappers",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iPcZoneManager const *)arg1)->IsColliderWrappers();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_SetLoadingMode(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    int arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcZoneManager_SetLoadingMode",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetLoadingMode(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_GetLoadingMode(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    int result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcZoneManager_GetLoadingMode",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (int)((iPcZoneManager const *)arg1)->GetLoadingMode();
    
    {
        resultobj = SWIG_From_int((int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_Load__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    iDocumentNode *arg2 = (iDocumentNode *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcZoneManager_Load",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iDocumentNode, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->Load(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_Load__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    char *arg2 = (char *) 0 ;
    char *arg3 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcZoneManager_Load",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    result = (bool)(arg1)->Load((char const *)arg2,(char const *)arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_Load(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[4];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcZoneManager, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iDocumentNode, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                return _wrap_iPcZoneManager_Load__SWIG_0(self,args);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcZoneManager, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_AsCharPtr(argv[1], (char **)(0));
            if (_v) {
                _v = SWIG_AsCharPtr(argv[2], (char **)(0));
                if (_v) {
                    return _wrap_iPcZoneManager_Load__SWIG_1(self,args);
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcZoneManager_Load'");
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_CreateZone(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    char *arg2 = (char *) 0 ;
    iCelZone *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcZoneManager_CreateZone",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iCelZone *)(arg1)->CreateZone((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelZone, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_GetZoneCount(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    size_t result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcZoneManager_GetZoneCount",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = ((iPcZoneManager const *)arg1)->GetZoneCount();
    
    {
        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_GetZone(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    int arg2 ;
    iCelZone *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcZoneManager_GetZone",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (iCelZone *)((iPcZoneManager const *)arg1)->GetZone(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelZone, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_FindZone(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    char *arg2 = (char *) 0 ;
    iCelZone *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcZoneManager_FindZone",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iCelZone *)((iPcZoneManager const *)arg1)->FindZone((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelZone, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_RemoveZone(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    iCelZone *arg2 = (iCelZone *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcZoneManager_RemoveZone",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelZone, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->RemoveZone(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_RemoveAllZones(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcZoneManager_RemoveAllZones",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->RemoveAllZones();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_CreateRegion(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    char *arg2 = (char *) 0 ;
    iCelRegion *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcZoneManager_CreateRegion",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iCelRegion *)(arg1)->CreateRegion((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelRegion, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_GetRegionCount(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    size_t result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcZoneManager_GetRegionCount",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = ((iPcZoneManager const *)arg1)->GetRegionCount();
    
    {
        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_GetRegion(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    int arg2 ;
    iCelRegion *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcZoneManager_GetRegion",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (iCelRegion *)((iPcZoneManager const *)arg1)->GetRegion(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelRegion, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_FindRegion(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    char *arg2 = (char *) 0 ;
    iCelRegion *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcZoneManager_FindRegion",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (iCelRegion *)((iPcZoneManager const *)arg1)->FindRegion((char const *)arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelRegion, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_RemoveRegion(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    iCelRegion *arg2 = (iCelRegion *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcZoneManager_RemoveRegion",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->RemoveRegion(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_RemoveAllRegions(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcZoneManager_RemoveAllRegions",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->RemoveAllRegions();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_FindStartLocations(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    iStringArray *arg2 = (iStringArray *) 0 ;
    iStringArray *arg3 = (iStringArray *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcZoneManager_FindStartLocations",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iStringArray, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_iStringArray, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(3)) SWIG_fail;
    (arg1)->FindStartLocations(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_GetLastStartLocation(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    iString *arg2 = (iString *) 0 ;
    iString *arg3 = (iString *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcZoneManager_GetLastStartLocation",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iString, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_iString, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(3)) SWIG_fail;
    (arg1)->GetLastStartLocation(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_GetLastStartRegionName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcZoneManager_GetLastStartRegionName",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)(arg1)->GetLastStartRegionName();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_GetLastStartName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcZoneManager_GetLastStartName",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)(arg1)->GetLastStartName();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_PointCamera__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    char *arg2 = (char *) 0 ;
    char *arg3 = (char *) 0 ;
    char *arg4 = (char *) 0 ;
    int result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcZoneManager_PointCamera",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
        SWIG_arg_fail(4);SWIG_fail;
    }
    result = (int)(arg1)->PointCamera((char const *)arg2,(char const *)arg3,(char const *)arg4);
    
    {
        resultobj = SWIG_From_int((int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_PointCamera__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    char *arg2 = (char *) 0 ;
    char *arg3 = (char *) 0 ;
    int result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcZoneManager_PointCamera",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    result = (int)(arg1)->PointCamera((char const *)arg2,(char const *)arg3);
    
    {
        resultobj = SWIG_From_int((int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_PointCamera(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[5];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 4); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcZoneManager, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_AsCharPtr(argv[1], (char **)(0));
            if (_v) {
                _v = SWIG_AsCharPtr(argv[2], (char **)(0));
                if (_v) {
                    return _wrap_iPcZoneManager_PointCamera__SWIG_1(self,args);
                }
            }
        }
    }
    if (argc == 4) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcZoneManager, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_AsCharPtr(argv[1], (char **)(0));
            if (_v) {
                _v = SWIG_AsCharPtr(argv[2], (char **)(0));
                if (_v) {
                    _v = SWIG_AsCharPtr(argv[3], (char **)(0));
                    if (_v) {
                        return _wrap_iPcZoneManager_PointCamera__SWIG_0(self,args);
                    }
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcZoneManager_PointCamera'");
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_PointMesh__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    char *arg2 = (char *) 0 ;
    char *arg3 = (char *) 0 ;
    char *arg4 = (char *) 0 ;
    int result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcZoneManager_PointMesh",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
        SWIG_arg_fail(4);SWIG_fail;
    }
    result = (int)(arg1)->PointMesh((char const *)arg2,(char const *)arg3,(char const *)arg4);
    
    {
        resultobj = SWIG_From_int((int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_PointMesh__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    char *arg2 = (char *) 0 ;
    char *arg3 = (char *) 0 ;
    int result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcZoneManager_PointMesh",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    result = (int)(arg1)->PointMesh((char const *)arg2,(char const *)arg3);
    
    {
        resultobj = SWIG_From_int((int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcZoneManager_PointMesh(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[5];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 4); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcZoneManager, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_AsCharPtr(argv[1], (char **)(0));
            if (_v) {
                _v = SWIG_AsCharPtr(argv[2], (char **)(0));
                if (_v) {
                    return _wrap_iPcZoneManager_PointMesh__SWIG_1(self,args);
                }
            }
        }
    }
    if (argc == 4) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcZoneManager, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_AsCharPtr(argv[1], (char **)(0));
            if (_v) {
                _v = SWIG_AsCharPtr(argv[2], (char **)(0));
                if (_v) {
                    _v = SWIG_AsCharPtr(argv[3], (char **)(0));
                    if (_v) {
                        return _wrap_iPcZoneManager_PointMesh__SWIG_0(self,args);
                    }
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcZoneManager_PointMesh'");
    return NULL;
}


static PyObject *_wrap_delete_iPcZoneManager(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcZoneManager *arg1 = (iPcZoneManager *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcZoneManager",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcZoneManager_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcZoneManager, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateZoneManager(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcZoneManager *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateZoneManager",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcZoneManager *)celCreateZoneManager(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcZoneManager, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetZoneManager(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcZoneManager *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetZoneManager",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcZoneManager *)celGetZoneManager(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcZoneManager, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcZoneManager(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcZoneManager *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcZoneManager",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcZoneManager *)scfQuery_iPcZoneManager(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcZoneManager, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCommandInput_Activate__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCommandInput *arg1 = (iPcCommandInput *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcCommandInput_Activate",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCommandInput, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->Activate(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCommandInput_Activate__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCommandInput *arg1 = (iPcCommandInput *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcCommandInput_Activate",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCommandInput, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->Activate();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCommandInput_Activate(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[3];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcCommandInput, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            return _wrap_iPcCommandInput_Activate__SWIG_1(self,args);
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcCommandInput, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_bool(argv[1]);
            if (_v) {
                return _wrap_iPcCommandInput_Activate__SWIG_0(self,args);
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcCommandInput_Activate'");
    return NULL;
}


static PyObject *_wrap_iPcCommandInput_ScreenCoordinates__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCommandInput *arg1 = (iPcCommandInput *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcCommandInput_ScreenCoordinates",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCommandInput, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->ScreenCoordinates(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCommandInput_ScreenCoordinates__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCommandInput *arg1 = (iPcCommandInput *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcCommandInput_ScreenCoordinates",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCommandInput, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->ScreenCoordinates();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCommandInput_ScreenCoordinates(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[3];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcCommandInput, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            return _wrap_iPcCommandInput_ScreenCoordinates__SWIG_1(self,args);
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcCommandInput, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_bool(argv[1]);
            if (_v) {
                return _wrap_iPcCommandInput_ScreenCoordinates__SWIG_0(self,args);
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcCommandInput_ScreenCoordinates'");
    return NULL;
}


static PyObject *_wrap_iPcCommandInput_ScreenToCentered__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCommandInput *arg1 = (iPcCommandInput *) 0 ;
    float arg2 ;
    float arg3 ;
    float result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcCommandInput_ScreenToCentered",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCommandInput, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (float)(arg1)->ScreenToCentered(arg2,arg3);
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCommandInput_ScreenToCentered__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCommandInput *arg1 = (iPcCommandInput *) 0 ;
    float arg2 ;
    float result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcCommandInput_ScreenToCentered",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCommandInput, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (float)(arg1)->ScreenToCentered(arg2);
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCommandInput_ScreenToCentered(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[4];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcCommandInput, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_float(argv[1]);
            if (_v) {
                return _wrap_iPcCommandInput_ScreenToCentered__SWIG_1(self,args);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcCommandInput, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_float(argv[1]);
            if (_v) {
                _v = SWIG_Check_float(argv[2]);
                if (_v) {
                    return _wrap_iPcCommandInput_ScreenToCentered__SWIG_0(self,args);
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcCommandInput_ScreenToCentered'");
    return NULL;
}


static PyObject *_wrap_iPcCommandInput_CenteredToScreen__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCommandInput *arg1 = (iPcCommandInput *) 0 ;
    float arg2 ;
    float arg3 ;
    float result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcCommandInput_CenteredToScreen",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCommandInput, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (float)(arg1)->CenteredToScreen(arg2,arg3);
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCommandInput_CenteredToScreen__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCommandInput *arg1 = (iPcCommandInput *) 0 ;
    float arg2 ;
    float result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcCommandInput_CenteredToScreen",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCommandInput, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (float)(arg1)->CenteredToScreen(arg2);
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCommandInput_CenteredToScreen(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[4];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcCommandInput, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_float(argv[1]);
            if (_v) {
                return _wrap_iPcCommandInput_CenteredToScreen__SWIG_1(self,args);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcCommandInput, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_float(argv[1]);
            if (_v) {
                _v = SWIG_Check_float(argv[2]);
                if (_v) {
                    return _wrap_iPcCommandInput_CenteredToScreen__SWIG_0(self,args);
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcCommandInput_CenteredToScreen'");
    return NULL;
}


static PyObject *_wrap_iPcCommandInput_LoadConfig(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCommandInput *arg1 = (iPcCommandInput *) 0 ;
    char *arg2 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcCommandInput_LoadConfig",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCommandInput, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (bool)(arg1)->LoadConfig((char const *)arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCommandInput_Bind(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCommandInput *arg1 = (iPcCommandInput *) 0 ;
    char *arg2 = (char *) 0 ;
    char *arg3 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcCommandInput_Bind",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCommandInput, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    result = (bool)(arg1)->Bind((char const *)arg2,(char const *)arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCommandInput_GetBind(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCommandInput *arg1 = (iPcCommandInput *) 0 ;
    char *arg2 = (char *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcCommandInput_GetBind",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCommandInput, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (char *)((iPcCommandInput const *)arg1)->GetBind((char const *)arg2);
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCommandInput_RemoveBind(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCommandInput *arg1 = (iPcCommandInput *) 0 ;
    char *arg2 = (char *) 0 ;
    char *arg3 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcCommandInput_RemoveBind",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCommandInput, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    result = (bool)(arg1)->RemoveBind((char const *)arg2,(char const *)arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCommandInput_RemoveAllBinds(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCommandInput *arg1 = (iPcCommandInput *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcCommandInput_RemoveAllBinds",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCommandInput, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->RemoveAllBinds();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcCommandInput(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCommandInput *arg1 = (iPcCommandInput *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcCommandInput",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCommandInput, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcCommandInput_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcCommandInput, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateCommandInput(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcCommandInput *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateCommandInput",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcCommandInput *)celCreateCommandInput(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcCommandInput, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetCommandInput(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcCommandInput *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetCommandInput",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcCommandInput *)celGetCommandInput(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcCommandInput, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcCommandInput(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcCommandInput *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcCommandInput",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcCommandInput *)scfQuery_iPcCommandInput(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcCommandInput, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcGravityCallback_Callback(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcGravityCallback *arg1 = (iPcGravityCallback *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcGravityCallback_Callback",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcGravityCallback, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->Callback();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcGravityCallback(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcGravityCallback *arg1 = (iPcGravityCallback *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcGravityCallback",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcGravityCallback, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcGravityCallback_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcGravityCallback, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iPcLinearMovement_SetAnchor(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    iPcMesh *arg2 = (iPcMesh *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_SetAnchor",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetAnchor(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_GetAnchor(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    iPcMesh *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcLinearMovement_GetAnchor",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMesh *)((iPcLinearMovement const *)arg1)->GetAnchor();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMesh, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetAngularVelocity__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    csVector3 *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_SetAngularVelocity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetAngularVelocity((csVector3 const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetAngularVelocity__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    csVector3 *arg2 = 0 ;
    csVector3 *arg3 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcLinearMovement_SetAngularVelocity",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->SetAngularVelocity((csVector3 const &)*arg2,(csVector3 const &)*arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetAngularVelocity(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[4];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcLinearMovement, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr = 0;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_csVector3, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = (ptr != 0);
                }
            }
            if (_v) {
                return _wrap_iPcLinearMovement_SetAngularVelocity__SWIG_0(self,args);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcLinearMovement, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr = 0;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_csVector3, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = (ptr != 0);
                }
            }
            if (_v) {
                {
                    void *ptr = 0;
                    if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_csVector3, 0) == -1) {
                        _v = 0;
                        PyErr_Clear();
                    } else {
                        _v = (ptr != 0);
                    }
                }
                if (_v) {
                    return _wrap_iPcLinearMovement_SetAngularVelocity__SWIG_1(self,args);
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcLinearMovement_SetAngularVelocity'");
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetSpeed(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_SetSpeed",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetSpeed(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetVelocity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    csVector3 *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_SetVelocity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetVelocity((csVector3 const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_AddVelocity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    csVector3 *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_AddVelocity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->AddVelocity((csVector3 const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_ClearWorldVelocity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcLinearMovement_ClearWorldVelocity",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->ClearWorldVelocity();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_GetVelocity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    csVector3 *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_GetVelocity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    ((iPcLinearMovement const *)arg1)->GetVelocity(*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_GetAngularVelocity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    csVector3 *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_GetAngularVelocity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    ((iPcLinearMovement const *)arg1)->GetAngularVelocity(*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_InitCD__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    iMeshWrapper *arg2 = (iMeshWrapper *) 0 ;
    float arg3 ;
    iPcCollisionDetection *arg4 = (iPcCollisionDetection *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcLinearMovement_InitCD",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iMeshWrapper, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_iPcCollisionDetection, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(4)) SWIG_fail;
    result = (bool)(arg1)->InitCD(arg2,arg3,arg4);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_InitCD__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    iMeshWrapper *arg2 = (iMeshWrapper *) 0 ;
    float arg3 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcLinearMovement_InitCD",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iMeshWrapper, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (bool)(arg1)->InitCD(arg2,arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_InitCD__SWIG_2(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    csVector3 *arg2 = 0 ;
    csVector3 *arg3 = 0 ;
    csVector3 *arg4 = 0 ;
    iPcCollisionDetection *arg5 = (iPcCollisionDetection *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:iPcLinearMovement_InitCD",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (arg4 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_iPcCollisionDetection, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(5)) SWIG_fail;
    result = (bool)(arg1)->InitCD((csVector3 const &)*arg2,(csVector3 const &)*arg3,(csVector3 const &)*arg4,arg5);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_InitCD__SWIG_3(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    csVector3 *arg2 = 0 ;
    csVector3 *arg3 = 0 ;
    csVector3 *arg4 = 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcLinearMovement_InitCD",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (arg4 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    result = (bool)(arg1)->InitCD((csVector3 const &)*arg2,(csVector3 const &)*arg3,(csVector3 const &)*arg4);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_GetCDDimensions(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    csVector3 *arg2 = 0 ;
    csVector3 *arg3 = 0 ;
    csVector3 *arg4 = 0 ;
    iPcCollisionDetection **arg5 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:iPcLinearMovement_GetCDDimensions",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (arg4 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_p_iPcCollisionDetection, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(5)) SWIG_fail;
        if (arg5 == NULL) {
            SWIG_null_ref("iPcCollisionDetection");
        }
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    (arg1)->GetCDDimensions(*arg2,*arg3,*arg4,*arg5);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_InitCD__SWIG_4(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    iPcCollisionDetection *arg2 = (iPcCollisionDetection *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_InitCD",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcCollisionDetection, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->InitCD(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_InitCD__SWIG_5(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcLinearMovement_InitCD",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)(arg1)->InitCD();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_InitCD(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[6];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 5); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcLinearMovement, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            return _wrap_iPcLinearMovement_InitCD__SWIG_5(self,args);
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcLinearMovement, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iPcCollisionDetection, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                return _wrap_iPcLinearMovement_InitCD__SWIG_4(self,args);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcLinearMovement, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iMeshWrapper, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                _v = SWIG_Check_float(argv[2]);
                if (_v) {
                    return _wrap_iPcLinearMovement_InitCD__SWIG_1(self,args);
                }
            }
        }
    }
    if (argc == 4) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcLinearMovement, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iMeshWrapper, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                _v = SWIG_Check_float(argv[2]);
                if (_v) {
                    {
                        void *ptr;
                        if (SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_iPcCollisionDetection, 0) == -1) {
                            _v = 0;
                            PyErr_Clear();
                        } else {
                            _v = 1;
                        }
                    }
                    if (_v) {
                        return _wrap_iPcLinearMovement_InitCD__SWIG_0(self,args);
                    }
                }
            }
        }
    }
    if (argc == 4) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcLinearMovement, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr = 0;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_csVector3, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = (ptr != 0);
                }
            }
            if (_v) {
                {
                    void *ptr = 0;
                    if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_csVector3, 0) == -1) {
                        _v = 0;
                        PyErr_Clear();
                    } else {
                        _v = (ptr != 0);
                    }
                }
                if (_v) {
                    {
                        void *ptr = 0;
                        if (SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_csVector3, 0) == -1) {
                            _v = 0;
                            PyErr_Clear();
                        } else {
                            _v = (ptr != 0);
                        }
                    }
                    if (_v) {
                        return _wrap_iPcLinearMovement_InitCD__SWIG_3(self,args);
                    }
                }
            }
        }
    }
    if (argc == 5) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcLinearMovement, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr = 0;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_csVector3, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = (ptr != 0);
                }
            }
            if (_v) {
                {
                    void *ptr = 0;
                    if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_csVector3, 0) == -1) {
                        _v = 0;
                        PyErr_Clear();
                    } else {
                        _v = (ptr != 0);
                    }
                }
                if (_v) {
                    {
                        void *ptr = 0;
                        if (SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_csVector3, 0) == -1) {
                            _v = 0;
                            PyErr_Clear();
                        } else {
                            _v = (ptr != 0);
                        }
                    }
                    if (_v) {
                        {
                            void *ptr;
                            if (SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_iPcCollisionDetection, 0) == -1) {
                                _v = 0;
                                PyErr_Clear();
                            } else {
                                _v = 1;
                            }
                        }
                        if (_v) {
                            return _wrap_iPcLinearMovement_InitCD__SWIG_2(self,args);
                        }
                    }
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcLinearMovement_InitCD'");
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_TimeDiff(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    csTicks result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcLinearMovement_TimeDiff",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (csTicks)(arg1)->TimeDiff();
    
    {
        resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_GetDRData(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    bool *arg2 = 0 ;
    float *arg3 = 0 ;
    csVector3 *arg4 = 0 ;
    float *arg5 = 0 ;
    iSector **arg6 = 0 ;
    csVector3 *arg7 = 0 ;
    csVector3 *arg8 = 0 ;
    float *arg9 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    PyObject * obj6 = 0 ;
    PyObject * obj7 = 0 ;
    PyObject * obj8 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:iPcLinearMovement_GetDRData",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_bool, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("bool");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_float, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("float");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (arg4 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_float, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(5)) SWIG_fail;
        if (arg5 == NULL) {
            SWIG_null_ref("float");
        }
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_p_iSector, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(6)) SWIG_fail;
        if (arg6 == NULL) {
            SWIG_null_ref("iSector");
        }
        if (SWIG_arg_fail(6)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(7)) SWIG_fail;
        if (arg7 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(8)) SWIG_fail;
        if (arg8 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(8)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj8, (void **)&arg9, SWIGTYPE_p_float, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(9)) SWIG_fail;
        if (arg9 == NULL) {
            SWIG_null_ref("float");
        }
        if (SWIG_arg_fail(9)) SWIG_fail;
    }
    (arg1)->GetDRData(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8,*arg9);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetDRData(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    bool arg2 ;
    float arg3 ;
    csVector3 *arg4 = 0 ;
    float arg5 ;
    iSector *arg6 = (iSector *) 0 ;
    csVector3 *arg7 = 0 ;
    csVector3 *arg8 = 0 ;
    float arg9 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    PyObject * obj6 = 0 ;
    PyObject * obj7 = 0 ;
    PyObject * obj8 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:iPcLinearMovement_SetDRData",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (arg4 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg5 = (float)(SWIG_As_float(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_iSector, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(6)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(7)) SWIG_fail;
        if (arg7 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(8)) SWIG_fail;
        if (arg8 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(8)) SWIG_fail;
    }
    {
        arg9 = (float)(SWIG_As_float(obj8)); 
        if (SWIG_arg_fail(9)) SWIG_fail;
    }
    (arg1)->SetDRData(arg2,arg3,*arg4,arg5,arg6,*arg7,*arg8,arg9);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetSoftDRData(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    bool arg2 ;
    float arg3 ;
    csVector3 *arg4 = 0 ;
    float arg5 ;
    iSector *arg6 = (iSector *) 0 ;
    csVector3 *arg7 = 0 ;
    csVector3 *arg8 = 0 ;
    float arg9 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    PyObject * obj6 = 0 ;
    PyObject * obj7 = 0 ;
    PyObject * obj8 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:iPcLinearMovement_SetSoftDRData",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (arg4 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg5 = (float)(SWIG_As_float(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_iSector, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(6)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(7)) SWIG_fail;
        if (arg7 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(7)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj7, (void **)&arg8, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(8)) SWIG_fail;
        if (arg8 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(8)) SWIG_fail;
    }
    {
        arg9 = (float)(SWIG_As_float(obj8)); 
        if (SWIG_arg_fail(9)) SWIG_fail;
    }
    (arg1)->SetSoftDRData(arg2,arg3,*arg4,arg5,arg6,*arg7,*arg8,arg9);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetFullPosition__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    csVector3 *arg2 = 0 ;
    float arg3 ;
    iSector *arg4 = (iSector *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcLinearMovement_SetFullPosition",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_iSector, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(4)) SWIG_fail;
    (arg1)->SetFullPosition((csVector3 const &)*arg2,arg3,(iSector const *)arg4);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetPosition__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    csVector3 *arg2 = 0 ;
    float arg3 ;
    iSector *arg4 = (iSector *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcLinearMovement_SetPosition",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_iSector, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(4)) SWIG_fail;
    (arg1)->SetPosition((csVector3 const &)*arg2,arg3,(iSector const *)arg4);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_GetLastPosition(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    csVector3 *arg2 = 0 ;
    float *arg3 = 0 ;
    iSector **arg4 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcLinearMovement_GetLastPosition",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_float, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("float");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_p_iSector, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (arg4 == NULL) {
            SWIG_null_ref("iSector");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    (arg1)->GetLastPosition(*arg2,*arg3,*arg4);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_GetLastFullPosition(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    csVector3 *arg2 = 0 ;
    float *arg3 = 0 ;
    iSector **arg4 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcLinearMovement_GetLastFullPosition",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_float, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("float");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_p_iSector, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (arg4 == NULL) {
            SWIG_null_ref("iSector");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    (arg1)->GetLastFullPosition(*arg2,*arg3,*arg4);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_IsPath(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcLinearMovement_IsPath",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iPcLinearMovement const *)arg1)->IsPath();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_GetSector(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    iSector *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcLinearMovement_GetSector",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iSector *)(arg1)->GetSector();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iSector, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_ExtrapolatePosition(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_ExtrapolatePosition",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->ExtrapolatePosition(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_UpdateDRDelta(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    csTicks arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_UpdateDRDelta",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csTicks)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->UpdateDRDelta(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_UpdateDR(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    csTicks arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_UpdateDR",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csTicks)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->UpdateDR(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetPath(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    iPath *arg2 = (iPath *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_SetPath",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPath, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetPath(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetPathTime(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_SetPathTime",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetPathTime(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetPathSpeed(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_SetPathSpeed",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetPathSpeed(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetPathAction(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    int arg2 ;
    char *arg3 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcLinearMovement_SetPathAction",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    (arg1)->SetPathAction(arg2,(char const *)arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetPathSector(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_SetPathSector",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->SetPathSector((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_IsOnGround(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcLinearMovement_IsOnGround",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iPcLinearMovement const *)arg1)->IsOnGround();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetOnGround(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_SetOnGround",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetOnGround(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetHugGround(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_SetHugGround",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetHugGround(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetDeltaLimit(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_SetDeltaLimit",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetDeltaLimit(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_RotateV(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    float arg2 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_RotateV",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (bool)(arg1)->RotateV(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetGravity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_SetGravity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetGravity(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_GetGravity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcLinearMovement_GetGravity",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)(arg1)->GetGravity();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_ResetGravity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcLinearMovement_ResetGravity",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->ResetGravity();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_AddGravityCallback(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    iPcGravityCallback *arg2 = (iPcGravityCallback *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_AddGravityCallback",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcGravityCallback, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->AddGravityCallback(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_RemoveGravityCallback(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    iPcGravityCallback *arg2 = (iPcGravityCallback *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcLinearMovement_RemoveGravityCallback",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcGravityCallback, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->RemoveGravityCallback(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_GetPortalDisplacement(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    csVector3 result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcLinearMovement_GetPortalDisplacement",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (arg1)->GetPortalDisplacement();
    
    {
        csVector3 * resultptr;
        resultptr = new csVector3((csVector3 &)(result));
        resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_csVector3, 1);
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_ClearPortalDisplacement(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcLinearMovement_ClearPortalDisplacement",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->ClearPortalDisplacement();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetFullPosition__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    char *arg2 = (char *) 0 ;
    float arg3 ;
    iSector *arg4 = (iSector *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcLinearMovement_SetFullPosition",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_iSector, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(4)) SWIG_fail;
    (arg1)->SetFullPosition((char const *)arg2,arg3,arg4);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetFullPosition(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[5];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 4); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 4) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcLinearMovement, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr = 0;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_csVector3, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = (ptr != 0);
                }
            }
            if (_v) {
                _v = SWIG_Check_float(argv[2]);
                if (_v) {
                    {
                        void *ptr;
                        if (SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_iSector, 0) == -1) {
                            _v = 0;
                            PyErr_Clear();
                        } else {
                            _v = 1;
                        }
                    }
                    if (_v) {
                        return _wrap_iPcLinearMovement_SetFullPosition__SWIG_0(self,args);
                    }
                }
            }
        }
    }
    if (argc == 4) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcLinearMovement, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_AsCharPtr(argv[1], (char **)(0));
            if (_v) {
                _v = SWIG_Check_float(argv[2]);
                if (_v) {
                    {
                        void *ptr;
                        if (SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_iSector, 0) == -1) {
                            _v = 0;
                            PyErr_Clear();
                        } else {
                            _v = 1;
                        }
                    }
                    if (_v) {
                        return _wrap_iPcLinearMovement_SetFullPosition__SWIG_1(self,args);
                    }
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcLinearMovement_SetFullPosition'");
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetPosition__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    char *arg2 = (char *) 0 ;
    float arg3 ;
    iSector *arg4 = (iSector *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcLinearMovement_SetPosition",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_iSector, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(4)) SWIG_fail;
    (arg1)->SetPosition((char const *)arg2,arg3,arg4);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcLinearMovement_SetPosition(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[5];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 4); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 4) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcLinearMovement, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr = 0;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_csVector3, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = (ptr != 0);
                }
            }
            if (_v) {
                _v = SWIG_Check_float(argv[2]);
                if (_v) {
                    {
                        void *ptr;
                        if (SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_iSector, 0) == -1) {
                            _v = 0;
                            PyErr_Clear();
                        } else {
                            _v = 1;
                        }
                    }
                    if (_v) {
                        return _wrap_iPcLinearMovement_SetPosition__SWIG_0(self,args);
                    }
                }
            }
        }
    }
    if (argc == 4) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcLinearMovement, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_AsCharPtr(argv[1], (char **)(0));
            if (_v) {
                _v = SWIG_Check_float(argv[2]);
                if (_v) {
                    {
                        void *ptr;
                        if (SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_iSector, 0) == -1) {
                            _v = 0;
                            PyErr_Clear();
                        } else {
                            _v = 1;
                        }
                    }
                    if (_v) {
                        return _wrap_iPcLinearMovement_SetPosition__SWIG_1(self,args);
                    }
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcLinearMovement_SetPosition'");
    return NULL;
}


static PyObject *_wrap_delete_iPcLinearMovement(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcLinearMovement *arg1 = (iPcLinearMovement *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcLinearMovement",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcLinearMovement, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcLinearMovement_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcLinearMovement, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateLinearMovement(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcLinearMovement *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateLinearMovement",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcLinearMovement *)celCreateLinearMovement(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcLinearMovement, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetLinearMovement(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcLinearMovement *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetLinearMovement",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcLinearMovement *)celGetLinearMovement(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcLinearMovement, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcLinearMovement(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcLinearMovement *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcLinearMovement",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcLinearMovement *)scfQuery_iPcLinearMovement(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcLinearMovement, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_Forward(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcActorMove_Forward",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->Forward(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_IsMovingForward(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcActorMove_IsMovingForward",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)(arg1)->IsMovingForward();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_Backward(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcActorMove_Backward",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->Backward(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_IsMovingBackward(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcActorMove_IsMovingBackward",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)(arg1)->IsMovingBackward();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_StrafeLeft(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcActorMove_StrafeLeft",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->StrafeLeft(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_IsStrafingLeft(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcActorMove_IsStrafingLeft",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)(arg1)->IsStrafingLeft();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_StrafeRight(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcActorMove_StrafeRight",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->StrafeRight(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_IsStrafingRight(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcActorMove_IsStrafingRight",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)(arg1)->IsStrafingRight();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_RotateLeft(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcActorMove_RotateLeft",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->RotateLeft(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_IsRotatingLeft(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcActorMove_IsRotatingLeft",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)(arg1)->IsRotatingLeft();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_RotateRight(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcActorMove_RotateRight",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->RotateRight(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_IsRotatingRight(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcActorMove_IsRotatingRight",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)(arg1)->IsRotatingRight();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_RotateTo(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcActorMove_RotateTo",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->RotateTo(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_Run(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcActorMove_Run",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->Run(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_IsRunning(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcActorMove_IsRunning",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)(arg1)->IsRunning();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_AutoRun(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcActorMove_AutoRun",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->AutoRun(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_IsAutoRunning(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcActorMove_IsAutoRunning",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)(arg1)->IsAutoRunning();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_Jump(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcActorMove_Jump",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->Jump();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_ToggleCameraMode(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcActorMove_ToggleCameraMode",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->ToggleCameraMode();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_SetMovementSpeed(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcActorMove_SetMovementSpeed",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetMovementSpeed(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_GetMovementSpeed(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcActorMove_GetMovementSpeed",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)((iPcActorMove const *)arg1)->GetMovementSpeed();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_SetRunningSpeed(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcActorMove_SetRunningSpeed",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetRunningSpeed(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_GetRunningSpeed(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcActorMove_GetRunningSpeed",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)((iPcActorMove const *)arg1)->GetRunningSpeed();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_SetRotationSpeed(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcActorMove_SetRotationSpeed",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetRotationSpeed(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_GetRotationSpeed(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcActorMove_GetRotationSpeed",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)((iPcActorMove const *)arg1)->GetRotationSpeed();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_SetJumpingVelocity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcActorMove_SetJumpingVelocity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetJumpingVelocity(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcActorMove_GetJumpingVelocity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcActorMove_GetJumpingVelocity",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)((iPcActorMove const *)arg1)->GetJumpingVelocity();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcActorMove(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcActorMove *arg1 = (iPcActorMove *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcActorMove",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcActorMove, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcActorMove_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcActorMove, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateActorMove(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcActorMove *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateActorMove",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcActorMove *)celCreateActorMove(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcActorMove, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetActorMove(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcActorMove *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetActorMove",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcActorMove *)celGetActorMove(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcActorMove, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcActorMove(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcActorMove *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcActorMove",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcActorMove *)scfQuery_iPcActorMove(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcActorMove, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_SetRegion__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    iPcRegion *arg2 = (iPcRegion *) 0 ;
    bool arg3 ;
    char *arg4 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcCamera_SetRegion",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        arg3 = (bool)(SWIG_As_bool(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
        SWIG_arg_fail(4);SWIG_fail;
    }
    result = (bool)(arg1)->SetRegion(arg2,arg3,(char const *)arg4);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_SetRegion__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    iPcRegion *arg2 = (iPcRegion *) 0 ;
    bool arg3 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcCamera_SetRegion",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        arg3 = (bool)(SWIG_As_bool(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (bool)(arg1)->SetRegion(arg2,arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_SetRegion__SWIG_2(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    iPcRegion *arg2 = (iPcRegion *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcCamera_SetRegion",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcRegion, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->SetRegion(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_SetRegion(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[5];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 4); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iPcRegion, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                return _wrap_iPcCamera_SetRegion__SWIG_2(self,args);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iPcRegion, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                _v = SWIG_Check_bool(argv[2]);
                if (_v) {
                    return _wrap_iPcCamera_SetRegion__SWIG_1(self,args);
                }
            }
        }
    }
    if (argc == 4) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iPcRegion, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                _v = SWIG_Check_bool(argv[2]);
                if (_v) {
                    _v = SWIG_AsCharPtr(argv[3], (char **)(0));
                    if (_v) {
                        return _wrap_iPcCamera_SetRegion__SWIG_0(self,args);
                    }
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcCamera_SetRegion'");
    return NULL;
}


static PyObject *_wrap_iPcCamera_SetZoneManager__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    iPcZoneManager *arg2 = (iPcZoneManager *) 0 ;
    bool arg3 ;
    char *arg4 = (char *) 0 ;
    char *arg5 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:iPcCamera_SetZoneManager",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        arg3 = (bool)(SWIG_As_bool(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
        SWIG_arg_fail(4);SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj4, (char**)&arg5)) {
        SWIG_arg_fail(5);SWIG_fail;
    }
    result = (bool)(arg1)->SetZoneManager(arg2,arg3,(char const *)arg4,(char const *)arg5);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_SetZoneManager__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    iPcZoneManager *arg2 = (iPcZoneManager *) 0 ;
    bool arg3 ;
    char *arg4 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcCamera_SetZoneManager",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcZoneManager, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        arg3 = (bool)(SWIG_As_bool(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
        SWIG_arg_fail(4);SWIG_fail;
    }
    result = (bool)(arg1)->SetZoneManager(arg2,arg3,(char const *)arg4);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_SetZoneManager__SWIG_2(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    char *arg2 = (char *) 0 ;
    bool arg3 ;
    char *arg4 = (char *) 0 ;
    char *arg5 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:iPcCamera_SetZoneManager",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    {
        arg3 = (bool)(SWIG_As_bool(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
        SWIG_arg_fail(4);SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj4, (char**)&arg5)) {
        SWIG_arg_fail(5);SWIG_fail;
    }
    result = (bool)(arg1)->SetZoneManager((char const *)arg2,arg3,(char const *)arg4,(char const *)arg5);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_SetZoneManager__SWIG_3(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    char *arg2 = (char *) 0 ;
    bool arg3 ;
    char *arg4 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcCamera_SetZoneManager",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    {
        arg3 = (bool)(SWIG_As_bool(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj3, (char**)&arg4)) {
        SWIG_arg_fail(4);SWIG_fail;
    }
    result = (bool)(arg1)->SetZoneManager((char const *)arg2,arg3,(char const *)arg4);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_SetZoneManager(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[6];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 5); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 4) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iPcZoneManager, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                _v = SWIG_Check_bool(argv[2]);
                if (_v) {
                    _v = SWIG_AsCharPtr(argv[3], (char **)(0));
                    if (_v) {
                        return _wrap_iPcCamera_SetZoneManager__SWIG_1(self,args);
                    }
                }
            }
        }
    }
    if (argc == 4) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_AsCharPtr(argv[1], (char **)(0));
            if (_v) {
                _v = SWIG_Check_bool(argv[2]);
                if (_v) {
                    _v = SWIG_AsCharPtr(argv[3], (char **)(0));
                    if (_v) {
                        return _wrap_iPcCamera_SetZoneManager__SWIG_3(self,args);
                    }
                }
            }
        }
    }
    if (argc == 5) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iPcZoneManager, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                _v = SWIG_Check_bool(argv[2]);
                if (_v) {
                    _v = SWIG_AsCharPtr(argv[3], (char **)(0));
                    if (_v) {
                        _v = SWIG_AsCharPtr(argv[4], (char **)(0));
                        if (_v) {
                            return _wrap_iPcCamera_SetZoneManager__SWIG_0(self,args);
                        }
                    }
                }
            }
        }
    }
    if (argc == 5) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_AsCharPtr(argv[1], (char **)(0));
            if (_v) {
                _v = SWIG_Check_bool(argv[2]);
                if (_v) {
                    _v = SWIG_AsCharPtr(argv[3], (char **)(0));
                    if (_v) {
                        _v = SWIG_AsCharPtr(argv[4], (char **)(0));
                        if (_v) {
                            return _wrap_iPcCamera_SetZoneManager__SWIG_2(self,args);
                        }
                    }
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcCamera_SetZoneManager'");
    return NULL;
}


static PyObject *_wrap_iPcCamera_SetRectangle(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    int arg2 ;
    int arg3 ;
    int arg4 ;
    int arg5 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:iPcCamera_SetRectangle",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (int)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg5 = (int)(SWIG_As_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    (arg1)->SetRectangle(arg2,arg3,arg4,arg5);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_GetCamera(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    iCamera *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcCamera_GetCamera",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iCamera *)((iPcCamera const *)arg1)->GetCamera();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCamera, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_GetView(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    iView *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcCamera_GetView",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iView *)((iPcCamera const *)arg1)->GetView();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iView, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_SetClearZBuffer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcCamera_SetClearZBuffer",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetClearZBuffer(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_GetClearZBuffer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcCamera_GetClearZBuffer",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iPcCamera const *)arg1)->GetClearZBuffer();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_SetClearScreen(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcCamera_SetClearScreen",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetClearScreen(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_GetClearScreen(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcCamera_GetClearScreen",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iPcCamera const *)arg1)->GetClearScreen();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_DisableDistanceClipping(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcCamera_DisableDistanceClipping",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->DisableDistanceClipping();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_EnableFixedDistanceClipping(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcCamera_EnableFixedDistanceClipping",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->EnableFixedDistanceClipping(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_EnableAdaptiveDistanceClipping(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    float arg2 ;
    float arg3 ;
    float arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcCamera_EnableAdaptiveDistanceClipping",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (float)(SWIG_As_float(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    (arg1)->EnableAdaptiveDistanceClipping(arg2,arg3,arg4);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_UseDistanceClipping(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcCamera_UseDistanceClipping",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iPcCamera const *)arg1)->UseDistanceClipping();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_UseFixedDistanceClipping(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcCamera_UseFixedDistanceClipping",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iPcCamera const *)arg1)->UseFixedDistanceClipping();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_GetFixedDistance(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcCamera_GetFixedDistance",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)((iPcCamera const *)arg1)->GetFixedDistance();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_GetAdaptiveMinFPS(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcCamera_GetAdaptiveMinFPS",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)((iPcCamera const *)arg1)->GetAdaptiveMinFPS();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_GetAdaptiveMaxFPS(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcCamera_GetAdaptiveMaxFPS",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)((iPcCamera const *)arg1)->GetAdaptiveMaxFPS();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_GetAdaptiveMinDistance(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcCamera_GetAdaptiveMinDistance",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)((iPcCamera const *)arg1)->GetAdaptiveMinDistance();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_SetAutoDraw(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcCamera_SetAutoDraw",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetAutoDraw(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCamera_Draw(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcCamera_Draw",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->Draw();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcCamera(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCamera *arg1 = (iPcCamera *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcCamera",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcCamera_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcCamera, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateCamera(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcCamera *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateCamera",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcCamera *)celCreateCamera(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcCamera, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetCamera(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcCamera *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetCamera",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcCamera *)celGetCamera(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcCamera, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcCamera(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcCamera *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcCamera",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcCamera *)scfQuery_iPcCamera(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcCamera, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetFollowEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcDefaultCamera_SetFollowEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetFollowEntity(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetMode__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    iPcDefaultCamera::CameraMode arg2 ;
    bool arg3 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcDefaultCamera_SetMode",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (iPcDefaultCamera::CameraMode)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (bool)(SWIG_As_bool(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (bool)(arg1)->SetMode((iPcDefaultCamera::CameraMode )arg2,arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetMode__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    iPcDefaultCamera::CameraMode arg2 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcDefaultCamera_SetMode",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (iPcDefaultCamera::CameraMode)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (bool)(arg1)->SetMode((iPcDefaultCamera::CameraMode )arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetMode(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[4];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcDefaultCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_int(argv[1]);
            if (_v) {
                return _wrap_iPcDefaultCamera_SetMode__SWIG_1(self,args);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcDefaultCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_int(argv[1]);
            if (_v) {
                _v = SWIG_Check_bool(argv[2]);
                if (_v) {
                    return _wrap_iPcDefaultCamera_SetMode__SWIG_0(self,args);
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcDefaultCamera_SetMode'");
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_GetMode(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    iPcDefaultCamera::CameraMode result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcDefaultCamera_GetMode",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcDefaultCamera::CameraMode)((iPcDefaultCamera const *)arg1)->GetMode();
    
    resultobj = SWIG_From_int((result));
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetModeName__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    char *arg2 = (char *) 0 ;
    bool arg3 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcDefaultCamera_SetModeName",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    {
        arg3 = (bool)(SWIG_As_bool(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (bool)(arg1)->SetModeName((char const *)arg2,arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetModeName__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    char *arg2 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcDefaultCamera_SetModeName",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (bool)(arg1)->SetModeName((char const *)arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetModeName(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[4];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcDefaultCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_AsCharPtr(argv[1], (char **)(0));
            if (_v) {
                return _wrap_iPcDefaultCamera_SetModeName__SWIG_1(self,args);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcDefaultCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_AsCharPtr(argv[1], (char **)(0));
            if (_v) {
                _v = SWIG_Check_bool(argv[2]);
                if (_v) {
                    return _wrap_iPcDefaultCamera_SetModeName__SWIG_0(self,args);
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcDefaultCamera_SetModeName'");
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_GetModeName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcDefaultCamera_GetModeName",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)((iPcDefaultCamera const *)arg1)->GetModeName();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_GetNextMode(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    iPcDefaultCamera::CameraMode result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcDefaultCamera_GetNextMode",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcDefaultCamera::CameraMode)((iPcDefaultCamera const *)arg1)->GetNextMode();
    
    resultobj = SWIG_From_int((result));
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetSpringParameters(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    float arg2 ;
    float arg3 ;
    float arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcDefaultCamera_SetSpringParameters",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (float)(SWIG_As_float(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    (arg1)->SetSpringParameters(arg2,arg3,arg4);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetMinMaxCameraDistance(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    float arg2 ;
    float arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcDefaultCamera_SetMinMaxCameraDistance",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->SetMinMaxCameraDistance(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetTurnSpeed(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcDefaultCamera_SetTurnSpeed",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetTurnSpeed(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetSwingCoef(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcDefaultCamera_SetSwingCoef",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetSwingCoef(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetFirstPersonOffset(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    csVector3 *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcDefaultCamera_SetFirstPersonOffset",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetFirstPersonOffset((csVector3 const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetThirdPersonOffset(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    csVector3 *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcDefaultCamera_SetThirdPersonOffset",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetThirdPersonOffset((csVector3 const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_CenterCamera(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcDefaultCamera_CenterCamera",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->CenterCamera();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetPitch(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcDefaultCamera_SetPitch",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetPitch(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_GetPitch(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcDefaultCamera_GetPitch",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)((iPcDefaultCamera const *)arg1)->GetPitch();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetPitchVelocity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcDefaultCamera_SetPitchVelocity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetPitchVelocity(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_GetPitchVelocity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcDefaultCamera_GetPitchVelocity",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)((iPcDefaultCamera const *)arg1)->GetPitchVelocity();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_MovePitch__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    float arg2 ;
    int arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcDefaultCamera_MovePitch",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->MovePitch(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_MovePitch__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcDefaultCamera_MovePitch",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->MovePitch(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_MovePitch(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[4];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcDefaultCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_float(argv[1]);
            if (_v) {
                return _wrap_iPcDefaultCamera_MovePitch__SWIG_1(self,args);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcDefaultCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_float(argv[1]);
            if (_v) {
                _v = SWIG_Check_int(argv[2]);
                if (_v) {
                    return _wrap_iPcDefaultCamera_MovePitch__SWIG_0(self,args);
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcDefaultCamera_MovePitch'");
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetYaw__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    float arg2 ;
    int arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcDefaultCamera_SetYaw",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->SetYaw(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetYaw__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcDefaultCamera_SetYaw",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetYaw(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetYaw(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[4];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcDefaultCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_float(argv[1]);
            if (_v) {
                return _wrap_iPcDefaultCamera_SetYaw__SWIG_1(self,args);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcDefaultCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_float(argv[1]);
            if (_v) {
                _v = SWIG_Check_int(argv[2]);
                if (_v) {
                    return _wrap_iPcDefaultCamera_SetYaw__SWIG_0(self,args);
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcDefaultCamera_SetYaw'");
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_MoveYaw__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    float arg2 ;
    int arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcDefaultCamera_MoveYaw",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->MoveYaw(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_MoveYaw__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcDefaultCamera_MoveYaw",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->MoveYaw(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_MoveYaw(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[4];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcDefaultCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_float(argv[1]);
            if (_v) {
                return _wrap_iPcDefaultCamera_MoveYaw__SWIG_1(self,args);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcDefaultCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_float(argv[1]);
            if (_v) {
                _v = SWIG_Check_int(argv[2]);
                if (_v) {
                    return _wrap_iPcDefaultCamera_MoveYaw__SWIG_0(self,args);
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcDefaultCamera_MoveYaw'");
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_GetYaw__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    int arg2 ;
    float result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcDefaultCamera_GetYaw",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (float)((iPcDefaultCamera const *)arg1)->GetYaw(arg2);
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_GetYaw__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcDefaultCamera_GetYaw",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)((iPcDefaultCamera const *)arg1)->GetYaw();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_GetYaw(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[3];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcDefaultCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            return _wrap_iPcDefaultCamera_GetYaw__SWIG_1(self,args);
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcDefaultCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_int(argv[1]);
            if (_v) {
                return _wrap_iPcDefaultCamera_GetYaw__SWIG_0(self,args);
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcDefaultCamera_GetYaw'");
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetYawVelocity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcDefaultCamera_SetYawVelocity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetYawVelocity(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_GetYawVelocity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcDefaultCamera_GetYawVelocity",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)((iPcDefaultCamera const *)arg1)->GetYawVelocity();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetDistance__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    float arg2 ;
    int arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcDefaultCamera_SetDistance",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->SetDistance(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetDistance__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcDefaultCamera_SetDistance",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetDistance(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcDefaultCamera_SetDistance(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[4];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcDefaultCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_float(argv[1]);
            if (_v) {
                return _wrap_iPcDefaultCamera_SetDistance__SWIG_1(self,args);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcDefaultCamera, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_float(argv[1]);
            if (_v) {
                _v = SWIG_Check_int(argv[2]);
                if (_v) {
                    return _wrap_iPcDefaultCamera_SetDistance__SWIG_0(self,args);
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcDefaultCamera_SetDistance'");
    return NULL;
}


static PyObject *_wrap_delete_iPcDefaultCamera(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcDefaultCamera *arg1 = (iPcDefaultCamera *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcDefaultCamera",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcDefaultCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcDefaultCamera_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcDefaultCamera, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateDefaultCamera(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcDefaultCamera *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateDefaultCamera",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcDefaultCamera *)celCreateDefaultCamera(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcDefaultCamera, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetDefaultCamera(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcDefaultCamera *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetDefaultCamera",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcDefaultCamera *)celGetDefaultCamera(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcDefaultCamera, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcDefaultCamera(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcDefaultCamera *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcDefaultCamera",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcDefaultCamera *)scfQuery_iPcDefaultCamera(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcDefaultCamera, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcSimpleCamera_SetDrawMesh(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcSimpleCamera *arg1 = (iPcSimpleCamera *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcSimpleCamera_SetDrawMesh",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcSimpleCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetDrawMesh(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcSimpleCamera_SetCameraOffset(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcSimpleCamera *arg1 = (iPcSimpleCamera *) 0 ;
    csVector3 *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcSimpleCamera_SetCameraOffset",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcSimpleCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetCameraOffset((csVector3 const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcSimpleCamera_SetLookAtOffset(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcSimpleCamera *arg1 = (iPcSimpleCamera *) 0 ;
    csVector3 *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcSimpleCamera_SetLookAtOffset",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcSimpleCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetLookAtOffset((csVector3 const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcSimpleCamera_SetMesh(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcSimpleCamera *arg1 = (iPcSimpleCamera *) 0 ;
    iPcMesh *arg2 = (iPcMesh *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcSimpleCamera_SetMesh",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcSimpleCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetMesh(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcSimpleCamera_Draw(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcSimpleCamera *arg1 = (iPcSimpleCamera *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcSimpleCamera_Draw",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcSimpleCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->Draw();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcSimpleCamera(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcSimpleCamera *arg1 = (iPcSimpleCamera *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcSimpleCamera",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcSimpleCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcSimpleCamera_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcSimpleCamera, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateSimpleCamera(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcSimpleCamera *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateSimpleCamera",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcSimpleCamera *)celCreateSimpleCamera(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcSimpleCamera, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetSimpleCamera(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcSimpleCamera *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetSimpleCamera",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcSimpleCamera *)celGetSimpleCamera(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcSimpleCamera, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcSimpleCamera(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcSimpleCamera *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcSimpleCamera",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcSimpleCamera *)scfQuery_iPcSimpleCamera(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcSimpleCamera, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelectListener_MouseDown(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelectListener *arg1 = (iPcMeshSelectListener *) 0 ;
    iPcMeshSelect *arg2 = (iPcMeshSelect *) 0 ;
    int arg3 ;
    int arg4 ;
    int arg5 ;
    iCelEntity *arg6 = (iCelEntity *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:iPcMeshSelectListener_MouseDown",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelectListener, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (int)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg5 = (int)(SWIG_As_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(6)) SWIG_fail;
    (arg1)->MouseDown(arg2,arg3,arg4,arg5,arg6);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelectListener_MouseUp(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelectListener *arg1 = (iPcMeshSelectListener *) 0 ;
    iPcMeshSelect *arg2 = (iPcMeshSelect *) 0 ;
    int arg3 ;
    int arg4 ;
    int arg5 ;
    iCelEntity *arg6 = (iCelEntity *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:iPcMeshSelectListener_MouseUp",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelectListener, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (int)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg5 = (int)(SWIG_As_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(6)) SWIG_fail;
    (arg1)->MouseUp(arg2,arg3,arg4,arg5,arg6);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelectListener_MouseMove(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelectListener *arg1 = (iPcMeshSelectListener *) 0 ;
    iPcMeshSelect *arg2 = (iPcMeshSelect *) 0 ;
    int arg3 ;
    int arg4 ;
    int arg5 ;
    iCelEntity *arg6 = (iCelEntity *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    PyObject * obj5 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOOO:iPcMeshSelectListener_MouseMove",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelectListener, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (int)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg5 = (int)(SWIG_As_int(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(6)) SWIG_fail;
    (arg1)->MouseMove(arg2,arg3,arg4,arg5,arg6);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcMeshSelectListener(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelectListener *arg1 = (iPcMeshSelectListener *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcMeshSelectListener",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelectListener, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcMeshSelectListener_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcMeshSelectListener, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iPcMeshSelect_AddMeshSelectListener(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    iPcMeshSelectListener *arg2 = (iPcMeshSelectListener *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMeshSelect_AddMeshSelectListener",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMeshSelectListener, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->AddMeshSelectListener(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_RemoveMeshSelectListener(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    iPcMeshSelectListener *arg2 = (iPcMeshSelectListener *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMeshSelect_RemoveMeshSelectListener",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMeshSelectListener, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->RemoveMeshSelectListener(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_SetCamera(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    iPcCamera *arg2 = (iPcCamera *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMeshSelect_SetCamera",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcCamera, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetCamera(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_SetMouseButtons__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    int arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMeshSelect_SetMouseButtons",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetMouseButtons(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_SetMouseButtons__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMeshSelect_SetMouseButtons",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->SetMouseButtons((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_SetMouseButtons(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[3];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcMeshSelect, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_int(argv[1]);
            if (_v) {
                return _wrap_iPcMeshSelect_SetMouseButtons__SWIG_0(self,args);
            }
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcMeshSelect, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_AsCharPtr(argv[1], (char **)(0));
            if (_v) {
                return _wrap_iPcMeshSelect_SetMouseButtons__SWIG_1(self,args);
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcMeshSelect_SetMouseButtons'");
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_GetMouseButtons(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    int result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMeshSelect_GetMouseButtons",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (int)((iPcMeshSelect const *)arg1)->GetMouseButtons();
    
    {
        resultobj = SWIG_From_int((int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_SetGlobalSelection(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMeshSelect_SetGlobalSelection",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetGlobalSelection(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_HasGlobalSelection(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMeshSelect_HasGlobalSelection",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iPcMeshSelect const *)arg1)->HasGlobalSelection();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_SetFollowMode(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMeshSelect_SetFollowMode",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetFollowMode(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_HasFollowMode(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMeshSelect_HasFollowMode",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iPcMeshSelect const *)arg1)->HasFollowMode();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_SetFollowAlwaysMode(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMeshSelect_SetFollowAlwaysMode",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetFollowAlwaysMode(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_HasFollowAlwaysMode(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMeshSelect_HasFollowAlwaysMode",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iPcMeshSelect const *)arg1)->HasFollowAlwaysMode();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_SetDragMode(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMeshSelect_SetDragMode",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetDragMode(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_HasDragMode(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMeshSelect_HasDragMode",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iPcMeshSelect const *)arg1)->HasDragMode();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_SetDragPlaneNormal(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    csVector3 *arg2 = 0 ;
    bool arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcMeshSelect_SetDragPlaneNormal",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (bool)(SWIG_As_bool(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->SetDragPlaneNormal((csVector3 const &)*arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_GetDragPlaneNormal(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    csVector3 *arg2 = 0 ;
    bool *arg3 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcMeshSelect_GetDragPlaneNormal",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_bool, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("bool");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    ((iPcMeshSelect const *)arg1)->GetDragPlaneNormal(*arg2,*arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_SetSendmoveEvent(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMeshSelect_SetSendmoveEvent",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetSendmoveEvent(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_HasSendmoveEvent(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMeshSelect_HasSendmoveEvent",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iPcMeshSelect const *)arg1)->HasSendmoveEvent();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_SetSendupEvent(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMeshSelect_SetSendupEvent",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetSendupEvent(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_HasSendupEvent(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMeshSelect_HasSendupEvent",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iPcMeshSelect const *)arg1)->HasSendupEvent();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_SetSenddownEvent(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMeshSelect_SetSenddownEvent",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetSenddownEvent(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_HasSenddownEvent(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMeshSelect_HasSenddownEvent",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iPcMeshSelect const *)arg1)->HasSenddownEvent();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_SetMaxSelectionDistance(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMeshSelect_SetMaxSelectionDistance",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetMaxSelectionDistance(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMeshSelect_GetMaxSelectionDistance(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMeshSelect_GetMaxSelectionDistance",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)((iPcMeshSelect const *)arg1)->GetMaxSelectionDistance();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcMeshSelect(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMeshSelect *arg1 = (iPcMeshSelect *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcMeshSelect",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMeshSelect, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcMeshSelect_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcMeshSelect, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateMeshSelect(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcMeshSelect *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateMeshSelect",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcMeshSelect *)celCreateMeshSelect(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMeshSelect, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetMeshSelect(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcMeshSelect *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetMeshSelect",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMeshSelect *)celGetMeshSelect(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMeshSelect, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcMeshSelect(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcMeshSelect *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcMeshSelect",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMeshSelect *)scfQuery_iPcMeshSelect(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMeshSelect, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMesh_SetPath(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMesh *arg1 = (iPcMesh *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMesh_SetPath",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->SetPath((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMesh_LoadMesh__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMesh *arg1 = (iPcMesh *) 0 ;
    char *arg2 = (char *) 0 ;
    char *arg3 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcMesh_LoadMesh",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    if (!SWIG_AsCharPtr(obj2, (char**)&arg3)) {
        SWIG_arg_fail(3);SWIG_fail;
    }
    result = (bool)(arg1)->SetMesh((char const *)arg2,(char const *)arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMesh_LoadMesh__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMesh *arg1 = (iPcMesh *) 0 ;
    iMeshWrapper *arg2 = (iMeshWrapper *) 0 ;
    bool arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcMesh_LoadMesh",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iMeshWrapper, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        arg3 = (bool)(SWIG_As_bool(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->SetMesh(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMesh_LoadMesh__SWIG_2(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMesh *arg1 = (iPcMesh *) 0 ;
    iMeshWrapper *arg2 = (iMeshWrapper *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMesh_LoadMesh",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iMeshWrapper, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetMesh(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMesh_LoadMesh(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[4];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcMesh, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iMeshWrapper, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                return _wrap_iPcMesh_LoadMesh__SWIG_2(self,args);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcMesh, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iMeshWrapper, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                _v = SWIG_Check_bool(argv[2]);
                if (_v) {
                    return _wrap_iPcMesh_LoadMesh__SWIG_1(self,args);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcMesh, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_AsCharPtr(argv[1], (char **)(0));
            if (_v) {
                _v = SWIG_AsCharPtr(argv[2], (char **)(0));
                if (_v) {
                    return _wrap_iPcMesh_LoadMesh__SWIG_0(self,args);
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcMesh_LoadMesh'");
    return NULL;
}


static PyObject *_wrap_iPcMesh_CreateEmptyThing(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMesh *arg1 = (iPcMesh *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMesh_CreateEmptyThing",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->CreateEmptyThing();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMesh_GetMesh(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMesh *arg1 = (iPcMesh *) 0 ;
    iMeshWrapper *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMesh_GetMesh",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iMeshWrapper *)((iPcMesh const *)arg1)->GetMesh();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iMeshWrapper, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMesh_MoveMesh(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMesh *arg1 = (iPcMesh *) 0 ;
    iSector *arg2 = (iSector *) 0 ;
    csVector3 *arg3 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcMesh_MoveMesh",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iSector, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->MoveMesh(arg2,(csVector3 const &)*arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMesh_SetAction__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMesh *arg1 = (iPcMesh *) 0 ;
    char *arg2 = (char *) 0 ;
    bool arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcMesh_SetAction",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    {
        arg3 = (bool)(SWIG_As_bool(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->SetAction((char const *)arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMesh_SetAction__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMesh *arg1 = (iPcMesh *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMesh_SetAction",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->SetAction((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMesh_SetAction(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[4];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcMesh, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_AsCharPtr(argv[1], (char **)(0));
            if (_v) {
                return _wrap_iPcMesh_SetAction__SWIG_1(self,args);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcMesh, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_AsCharPtr(argv[1], (char **)(0));
            if (_v) {
                _v = SWIG_Check_bool(argv[2]);
                if (_v) {
                    return _wrap_iPcMesh_SetAction__SWIG_0(self,args);
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcMesh_SetAction'");
    return NULL;
}


static PyObject *_wrap_iPcMesh_GetAction(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMesh *arg1 = (iPcMesh *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMesh_GetAction",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)(arg1)->GetAction();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMesh_SetReverseAction__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMesh *arg1 = (iPcMesh *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMesh_SetReverseAction",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetReverseAction(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMesh_SetReverseAction__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMesh *arg1 = (iPcMesh *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMesh_SetReverseAction",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->SetReverseAction();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMesh_SetReverseAction(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[3];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcMesh, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            return _wrap_iPcMesh_SetReverseAction__SWIG_1(self,args);
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcMesh, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            _v = SWIG_Check_bool(argv[1]);
            if (_v) {
                return _wrap_iPcMesh_SetReverseAction__SWIG_0(self,args);
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcMesh_SetReverseAction'");
    return NULL;
}


static PyObject *_wrap_iPcMesh_Hide(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMesh *arg1 = (iPcMesh *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMesh_Hide",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->Hide();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMesh_Show(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMesh *arg1 = (iPcMesh *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMesh_Show",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->Show();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMesh_IsVisible(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMesh *arg1 = (iPcMesh *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMesh_IsVisible",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iPcMesh const *)arg1)->IsVisible();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcMesh(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMesh *arg1 = (iPcMesh *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcMesh",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcMesh_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcMesh, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateMesh(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcMesh *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateMesh",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcMesh *)celCreateMesh(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMesh, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetMesh(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcMesh *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetMesh",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMesh *)celGetMesh(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMesh, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcMesh(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcMesh *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcMesh",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMesh *)scfQuery_iPcMesh(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMesh, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcTimer_WakeUp(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcTimer *arg1 = (iPcTimer *) 0 ;
    csTicks arg2 ;
    bool arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcTimer_WakeUp",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcTimer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (csTicks)(SWIG_As_unsigned_SS_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (bool)(SWIG_As_bool(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->WakeUp(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcTimer_WakeUpFrame(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcTimer *arg1 = (iPcTimer *) 0 ;
    int arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcTimer_WakeUpFrame",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcTimer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->WakeUpFrame(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcTimer_Clear(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcTimer *arg1 = (iPcTimer *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcTimer_Clear",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcTimer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->Clear();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcTimer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcTimer *arg1 = (iPcTimer *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcTimer",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcTimer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcTimer_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcTimer, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateTimer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcTimer *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateTimer",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcTimer *)celCreateTimer(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcTimer, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetTimer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcTimer *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetTimer",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcTimer *)celGetTimer(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcTimer, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcTimer(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcTimer *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcTimer",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcTimer *)scfQuery_iPcTimer(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcTimer, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcSolid_SetMesh(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcSolid *arg1 = (iPcSolid *) 0 ;
    iPcMesh *arg2 = (iPcMesh *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcSolid_SetMesh",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcSolid, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetMesh(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcSolid_GetMesh(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcSolid *arg1 = (iPcSolid *) 0 ;
    iPcMesh *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcSolid_GetMesh",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcSolid, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMesh *)((iPcSolid const *)arg1)->GetMesh();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMesh, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcSolid_GetCollider(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcSolid *arg1 = (iPcSolid *) 0 ;
    iCollider *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcSolid_GetCollider",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcSolid, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iCollider *)(arg1)->GetCollider();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCollider, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcSolid(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcSolid *arg1 = (iPcSolid *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcSolid",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcSolid, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcSolid_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcSolid, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateSolid(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcSolid *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateSolid",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcSolid *)celCreateSolid(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcSolid, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetSolid(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcSolid *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetSolid",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcSolid *)celGetSolid(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcSolid, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcSolid(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcSolid *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcSolid",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcSolid *)scfQuery_iPcSolid(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcSolid, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcGravity_CreateGravityColliderFromMesh__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcGravity *arg1 = (iPcGravity *) 0 ;
    iPcMesh *arg2 = (iPcMesh *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcGravity_CreateGravityColliderFromMesh",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcGravity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->CreateGravityCollider(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcGravity_CreateGravityColliderFromMesh__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcGravity *arg1 = (iPcGravity *) 0 ;
    csVector3 *arg2 = 0 ;
    csVector3 *arg3 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcGravity_CreateGravityColliderFromMesh",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcGravity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->CreateGravityCollider((csVector3 const &)*arg2,(csVector3 const &)*arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcGravity_CreateGravityColliderFromMesh(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[4];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcGravity, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iPcMesh, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                return _wrap_iPcGravity_CreateGravityColliderFromMesh__SWIG_0(self,args);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcGravity, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr = 0;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_csVector3, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = (ptr != 0);
                }
            }
            if (_v) {
                {
                    void *ptr = 0;
                    if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_csVector3, 0) == -1) {
                        _v = 0;
                        PyErr_Clear();
                    } else {
                        _v = (ptr != 0);
                    }
                }
                if (_v) {
                    return _wrap_iPcGravity_CreateGravityColliderFromMesh__SWIG_1(self,args);
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcGravity_CreateGravityColliderFromMesh'");
    return NULL;
}


static PyObject *_wrap_iPcGravity_GetGravityCollider(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcGravity *arg1 = (iPcGravity *) 0 ;
    iCollider *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcGravity_GetGravityCollider",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcGravity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iCollider *)(arg1)->GetGravityCollider();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCollider, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcGravity_SetMovable(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcGravity *arg1 = (iPcGravity *) 0 ;
    iPcMovable *arg2 = (iPcMovable *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcGravity_SetMovable",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcGravity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMovable, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetMovable(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcGravity_GetMovable(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcGravity *arg1 = (iPcGravity *) 0 ;
    iPcMovable *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcGravity_GetMovable",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcGravity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMovable *)(arg1)->GetMovable();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMovable, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcGravity_SetSolid(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcGravity *arg1 = (iPcGravity *) 0 ;
    iPcSolid *arg2 = (iPcSolid *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcGravity_SetSolid",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcGravity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcSolid, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetSolid(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcGravity_GetSolid(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcGravity *arg1 = (iPcGravity *) 0 ;
    iPcSolid *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcGravity_GetSolid",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcGravity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcSolid *)(arg1)->GetSolid();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcSolid, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcGravity_SetWeight(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcGravity *arg1 = (iPcGravity *) 0 ;
    float arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcGravity_SetWeight",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcGravity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (float)(SWIG_As_float(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetWeight(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcGravity_GetWeight(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcGravity *arg1 = (iPcGravity *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcGravity_GetWeight",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcGravity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (float)((iPcGravity const *)arg1)->GetWeight();
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcGravity_ClearForces(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcGravity *arg1 = (iPcGravity *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcGravity_ClearForces",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcGravity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->ClearForces();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcGravity_ClearPermanentForces(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcGravity *arg1 = (iPcGravity *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcGravity_ClearPermanentForces",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcGravity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->ClearPermanentForces();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcGravity_ResetSpeed(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcGravity *arg1 = (iPcGravity *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcGravity_ResetSpeed",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcGravity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->ResetSpeed();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcGravity_ApplyForce(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcGravity *arg1 = (iPcGravity *) 0 ;
    csVector3 *arg2 = 0 ;
    float arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcGravity_ApplyForce",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcGravity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->ApplyForce((csVector3 const &)*arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcGravity_ApplyPermanentForce(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcGravity *arg1 = (iPcGravity *) 0 ;
    csVector3 *arg2 = 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcGravity_ApplyPermanentForce",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcGravity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->ApplyPermanentForce((csVector3 const &)*arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcGravity_IsResting(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcGravity *arg1 = (iPcGravity *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcGravity_IsResting",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcGravity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iPcGravity const *)arg1)->IsResting();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcGravity_SetActive(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcGravity *arg1 = (iPcGravity *) 0 ;
    bool arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcGravity_SetActive",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcGravity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (bool)(SWIG_As_bool(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetActive(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcGravity_IsActive(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcGravity *arg1 = (iPcGravity *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcGravity_IsActive",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcGravity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iPcGravity const *)arg1)->IsActive();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcGravity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcGravity *arg1 = (iPcGravity *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcGravity",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcGravity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcGravity_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcGravity, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateGravity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcGravity *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateGravity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcGravity *)celCreateGravity(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcGravity, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetGravity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcGravity *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetGravity",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcGravity *)celGetGravity(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcGravity, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcGravity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcGravity *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcGravity",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcGravity *)scfQuery_iPcGravity(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcGravity, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMovable_SetMesh(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMovable *arg1 = (iPcMovable *) 0 ;
    iPcMesh *arg2 = (iPcMesh *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMovable_SetMesh",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMovable, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMesh, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetMesh(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMovable_GetMesh(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMovable *arg1 = (iPcMovable *) 0 ;
    iPcMesh *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMovable_GetMesh",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMovable, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMesh *)(arg1)->GetMesh();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMesh, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMovable_SetPos__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMovable *arg1 = (iPcMovable *) 0 ;
    iSector *arg2 = (iSector *) 0 ;
    csVector3 *arg3 = 0 ;
    int result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcMovable_SetPos",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMovable, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iSector, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (int)(arg1)->Move(arg2,(csVector3 const &)*arg3);
    
    {
        resultobj = SWIG_From_int((int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMovable_SetPos__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMovable *arg1 = (iPcMovable *) 0 ;
    csVector3 *arg2 = 0 ;
    int result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMovable_SetPos",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMovable, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(2)) SWIG_fail;
        if (arg2 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (int)(arg1)->Move((csVector3 const &)*arg2);
    
    {
        resultobj = SWIG_From_int((int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMovable_SetPos(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[4];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcMovable, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr = 0;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_csVector3, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = (ptr != 0);
                }
            }
            if (_v) {
                return _wrap_iPcMovable_SetPos__SWIG_1(self,args);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcMovable, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iSector, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                {
                    void *ptr = 0;
                    if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_csVector3, 0) == -1) {
                        _v = 0;
                        PyErr_Clear();
                    } else {
                        _v = (ptr != 0);
                    }
                }
                if (_v) {
                    return _wrap_iPcMovable_SetPos__SWIG_0(self,args);
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcMovable_SetPos'");
    return NULL;
}


static PyObject *_wrap_iPcMovable_AddConstraint(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMovable *arg1 = (iPcMovable *) 0 ;
    iPcMovableConstraint *arg2 = (iPcMovableConstraint *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMovable_AddConstraint",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMovable, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMovableConstraint, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->AddConstraint(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMovable_RemoveConstraint(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMovable *arg1 = (iPcMovable *) 0 ;
    iPcMovableConstraint *arg2 = (iPcMovableConstraint *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcMovable_RemoveConstraint",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMovable, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcMovableConstraint, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->RemoveConstraint(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcMovable_RemoveAllConstraints(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMovable *arg1 = (iPcMovable *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcMovable_RemoveAllConstraints",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMovable, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->RemoveAllConstraints();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcMovable(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMovable *arg1 = (iPcMovable *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcMovable",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMovable, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcMovable_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcMovable, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iPcMovableConstraint_CheckMove(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMovableConstraint *arg1 = (iPcMovableConstraint *) 0 ;
    iSector *arg2 = (iSector *) 0 ;
    csVector3 *arg3 = 0 ;
    csVector3 *arg4 = 0 ;
    csVector3 *arg5 = 0 ;
    int result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:iPcMovableConstraint_CheckMove",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMovableConstraint, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iSector, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (arg4 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_csVector3, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(5)) SWIG_fail;
        if (arg5 == NULL) {
            SWIG_null_ref("csVector3");
        }
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    result = (int)(arg1)->CheckMove(arg2,(csVector3 const &)*arg3,(csVector3 const &)*arg4,*arg5);
    
    {
        resultobj = SWIG_From_int((int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcMovableConstraint(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcMovableConstraint *arg1 = (iPcMovableConstraint *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcMovableConstraint",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcMovableConstraint, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcMovableConstraint_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcMovableConstraint, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateMovable(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcMovable *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateMovable",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcMovable *)celCreateMovable(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMovable, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetMovable(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcMovable *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetMovable",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMovable *)celGetMovable(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMovable, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcMovable(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcMovable *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcMovable",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcMovable *)scfQuery_iPcMovable(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcMovable, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventoryListener_AddChild(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventoryListener *arg1 = (iPcInventoryListener *) 0 ;
    iPcInventory *arg2 = (iPcInventory *) 0 ;
    iCelEntity *arg3 = (iCelEntity *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcInventoryListener_AddChild",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventoryListener, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(3)) SWIG_fail;
    (arg1)->AddChild(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventoryListener_RemoveChild(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventoryListener *arg1 = (iPcInventoryListener *) 0 ;
    iPcInventory *arg2 = (iPcInventory *) 0 ;
    iCelEntity *arg3 = (iCelEntity *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcInventoryListener_RemoveChild",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventoryListener, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(3)) SWIG_fail;
    (arg1)->RemoveChild(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcInventoryListener(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventoryListener *arg1 = (iPcInventoryListener *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcInventoryListener",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventoryListener, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcInventoryListener_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcInventoryListener, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iCelInventorySpaceSlot_GetEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelInventorySpaceSlot *arg1 = (iCelInventorySpaceSlot *) 0 ;
    iCelParameterBlock *arg2 = (iCelParameterBlock *) 0 ;
    iCelEntity *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelInventorySpaceSlot_GetEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelInventorySpaceSlot, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelParameterBlock, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iCelEntity *)(arg1)->GetEntity(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntity, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelInventorySpaceSlot_AddEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelInventorySpaceSlot *arg1 = (iCelInventorySpaceSlot *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iCelParameterBlock *arg3 = (iCelParameterBlock *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelInventorySpaceSlot_AddEntity",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelInventorySpaceSlot, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_iCelParameterBlock, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(3)) SWIG_fail;
    result = (bool)(arg1)->AddEntity(arg2,arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelInventorySpaceSlot_RemoveEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelInventorySpaceSlot *arg1 = (iCelInventorySpaceSlot *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelInventorySpaceSlot_RemoveEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelInventorySpaceSlot, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->RemoveEntity(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelInventorySpaceSlot_GetCount(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelInventorySpaceSlot *arg1 = (iCelInventorySpaceSlot *) 0 ;
    int result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelInventorySpaceSlot_GetCount",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelInventorySpaceSlot, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (int)(arg1)->GetCount();
    
    {
        resultobj = SWIG_From_int((int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelInventorySpaceSlot_RemoveAll(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelInventorySpaceSlot *arg1 = (iCelInventorySpaceSlot *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelInventorySpaceSlot_RemoveAll",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelInventorySpaceSlot, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->RemoveAll();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelInventorySpaceSlot_IsEmpty(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelInventorySpaceSlot *arg1 = (iCelInventorySpaceSlot *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelInventorySpaceSlot_IsEmpty",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelInventorySpaceSlot, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)(arg1)->IsEmpty();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iCelInventorySpaceSlot(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelInventorySpaceSlot *arg1 = (iCelInventorySpaceSlot *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iCelInventorySpaceSlot",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelInventorySpaceSlot, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iCelInventorySpaceSlot_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iCelInventorySpaceSlot, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iCelInventorySpace_GetSpaceTotal(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelInventorySpace *arg1 = (iCelInventorySpace *) 0 ;
    int result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelInventorySpace_GetSpaceTotal",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelInventorySpace, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (int)((iCelInventorySpace const *)arg1)->GetSpaceTotal();
    
    {
        resultobj = SWIG_From_int((int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelInventorySpace_GetSpaceLeft(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelInventorySpace *arg1 = (iCelInventorySpace *) 0 ;
    int result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelInventorySpace_GetSpaceLeft",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelInventorySpace, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (int)((iCelInventorySpace const *)arg1)->GetSpaceLeft();
    
    {
        resultobj = SWIG_From_int((int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelInventorySpace_GetSpaceTaken(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelInventorySpace *arg1 = (iCelInventorySpace *) 0 ;
    int result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelInventorySpace_GetSpaceTaken",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelInventorySpace, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (int)((iCelInventorySpace const *)arg1)->GetSpaceTaken();
    
    {
        resultobj = SWIG_From_int((int)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelInventorySpace_AddEntity__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelInventorySpace *arg1 = (iCelInventorySpace *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelInventorySpace_AddEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelInventorySpace, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->AddEntity(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelInventorySpace_RemoveEntity__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelInventorySpace *arg1 = (iCelInventorySpace *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelInventorySpace_RemoveEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelInventorySpace, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->RemoveEntity(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelInventorySpace_AddEntity__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelInventorySpace *arg1 = (iCelInventorySpace *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iCelParameterBlock *arg3 = (iCelParameterBlock *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iCelInventorySpace_AddEntity",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelInventorySpace, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_iCelParameterBlock, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(3)) SWIG_fail;
    result = (bool)(arg1)->AddEntity(arg2,arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelInventorySpace_AddEntity(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[4];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iCelInventorySpace, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iCelEntity, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                return _wrap_iCelInventorySpace_AddEntity__SWIG_0(self,args);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iCelInventorySpace, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iCelEntity, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                {
                    void *ptr;
                    if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_iCelParameterBlock, 0) == -1) {
                        _v = 0;
                        PyErr_Clear();
                    } else {
                        _v = 1;
                    }
                }
                if (_v) {
                    return _wrap_iCelInventorySpace_AddEntity__SWIG_1(self,args);
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iCelInventorySpace_AddEntity'");
    return NULL;
}


static PyObject *_wrap_iCelInventorySpace_RemoveEntity__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelInventorySpace *arg1 = (iCelInventorySpace *) 0 ;
    iCelParameterBlock *arg2 = (iCelParameterBlock *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelInventorySpace_RemoveEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelInventorySpace, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelParameterBlock, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->RemoveEntity(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelInventorySpace_RemoveEntity(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[3];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iCelInventorySpace, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iCelEntity, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                return _wrap_iCelInventorySpace_RemoveEntity__SWIG_0(self,args);
            }
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iCelInventorySpace, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iCelParameterBlock, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                return _wrap_iCelInventorySpace_RemoveEntity__SWIG_1(self,args);
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iCelInventorySpace_RemoveEntity'");
    return NULL;
}


static PyObject *_wrap_iCelInventorySpace_RemoveAll(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelInventorySpace *arg1 = (iCelInventorySpace *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iCelInventorySpace_RemoveAll",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelInventorySpace, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->RemoveAll();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelInventorySpace_GetSlot(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelInventorySpace *arg1 = (iCelInventorySpace *) 0 ;
    iCelParameterBlock *arg2 = (iCelParameterBlock *) 0 ;
    iCelInventorySpaceSlot *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelInventorySpace_GetSlot",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelInventorySpace, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelParameterBlock, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iCelInventorySpaceSlot *)(arg1)->GetSlot(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelInventorySpaceSlot, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iCelInventorySpace_GetEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelInventorySpace *arg1 = (iCelInventorySpace *) 0 ;
    iCelParameterBlock *arg2 = (iCelParameterBlock *) 0 ;
    iCelEntity *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iCelInventorySpace_GetEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelInventorySpace, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelParameterBlock, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iCelEntity *)(arg1)->GetEntity(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntity, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iCelInventorySpace(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelInventorySpace *arg1 = (iCelInventorySpace *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iCelInventorySpace",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelInventorySpace, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iCelInventorySpace_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iCelInventorySpace, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iPcInventory_AddInventoryListener(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    iPcInventoryListener *arg2 = (iPcInventoryListener *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcInventory_AddInventoryListener",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcInventoryListener, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->AddInventoryListener(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_RemoveInventoryListener(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    iPcInventoryListener *arg2 = (iPcInventoryListener *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcInventory_RemoveInventoryListener",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcInventoryListener, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->RemoveInventoryListener(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_AddEntity__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcInventory_AddEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->AddEntity(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_AddEntity__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iCelParameterBlock *arg3 = (iCelParameterBlock *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcInventory_AddEntity",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_iCelParameterBlock, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(3)) SWIG_fail;
    result = (bool)(arg1)->AddEntity(arg2,arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_AddEntity(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[4];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcInventory, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iCelEntity, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                return _wrap_iPcInventory_AddEntity__SWIG_0(self,args);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcInventory, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iCelEntity, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                {
                    void *ptr;
                    if (SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_iCelParameterBlock, 0) == -1) {
                        _v = 0;
                        PyErr_Clear();
                    } else {
                        _v = 1;
                    }
                }
                if (_v) {
                    return _wrap_iPcInventory_AddEntity__SWIG_1(self,args);
                }
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcInventory_AddEntity'");
    return NULL;
}


static PyObject *_wrap_iPcInventory_RemoveEntity__SWIG_0(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcInventory_RemoveEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->RemoveEntity(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_RemoveEntity__SWIG_1(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    iCelParameterBlock *arg2 = (iCelParameterBlock *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcInventory_RemoveEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelParameterBlock, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (bool)(arg1)->RemoveEntity(arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_RemoveEntity(PyObject *self, PyObject *args) {
    int argc;
    PyObject *argv[3];
    int ii;
    
    argc = PyObject_Length(args);
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = PyTuple_GetItem(args,ii);
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcInventory, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iCelEntity, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                return _wrap_iPcInventory_RemoveEntity__SWIG_0(self,args);
            }
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_iPcInventory, 0) == -1) {
                _v = 0;
                PyErr_Clear();
            } else {
                _v = 1;
            }
        }
        if (_v) {
            {
                void *ptr;
                if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_iCelParameterBlock, 0) == -1) {
                    _v = 0;
                    PyErr_Clear();
                } else {
                    _v = 1;
                }
            }
            if (_v) {
                return _wrap_iPcInventory_RemoveEntity__SWIG_1(self,args);
            }
        }
    }
    
    PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'iPcInventory_RemoveEntity'");
    return NULL;
}


static PyObject *_wrap_iPcInventory_RemoveAll(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcInventory_RemoveAll",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)(arg1)->RemoveAll();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_GetEntityCount(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    size_t result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcInventory_GetEntityCount",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = ((iPcInventory const *)arg1)->GetEntityCount();
    
    {
        resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_GetEntity(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    size_t arg2 ;
    iCelEntity *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcInventory_GetEntity",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    result = (iCelEntity *)((iPcInventory const *)arg1)->GetEntity(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntity, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_GetEntitySlot(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    iCelParameterBlock *arg2 = (iCelParameterBlock *) 0 ;
    iCelEntity *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcInventory_GetEntitySlot",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelParameterBlock, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iCelEntity *)((iPcInventory const *)arg1)->GetEntitySlot(arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelEntity, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_SetStrictCharacteristics(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    char *arg2 = (char *) 0 ;
    bool arg3 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcInventory_SetStrictCharacteristics",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    {
        arg3 = (bool)(SWIG_As_bool(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (bool)(arg1)->SetStrictCharacteristics((char const *)arg2,arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_HasStrictCharacteristics(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    char *arg2 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcInventory_HasStrictCharacteristics",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (bool)((iPcInventory const *)arg1)->HasStrictCharacteristics((char const *)arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_SetConstraints(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    char *arg2 = (char *) 0 ;
    float arg3 ;
    float arg4 ;
    float arg5 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:iPcInventory_SetConstraints",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (float)(SWIG_As_float(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        arg5 = (float)(SWIG_As_float(obj4)); 
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    result = (bool)(arg1)->SetConstraints((char const *)arg2,arg3,arg4,arg5);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_GetConstraints(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    char *arg2 = (char *) 0 ;
    float *arg3 = 0 ;
    float *arg4 = 0 ;
    float *arg5 = 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    PyObject * obj4 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOOO:iPcInventory_GetConstraints",&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_float, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(3)) SWIG_fail;
        if (arg3 == NULL) {
            SWIG_null_ref("float");
        }
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_float, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(4)) SWIG_fail;
        if (arg4 == NULL) {
            SWIG_null_ref("float");
        }
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    {
        SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_float, SWIG_POINTER_EXCEPTION | 0);
        if (SWIG_arg_fail(5)) SWIG_fail;
        if (arg5 == NULL) {
            SWIG_null_ref("float");
        }
        if (SWIG_arg_fail(5)) SWIG_fail;
    }
    result = (bool)((iPcInventory const *)arg1)->GetConstraints((char const *)arg2,*arg3,*arg4,*arg5);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_RemoveConstraints(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcInventory_RemoveConstraints",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->RemoveConstraints((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_RemoveAllConstraints(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcInventory_RemoveAllConstraints",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->RemoveAllConstraints();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_GetCurrentCharacteristic(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    char *arg2 = (char *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcInventory_GetCurrentCharacteristic",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (float)((iPcInventory const *)arg1)->GetCurrentCharacteristic((char const *)arg2);
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_MarkDirty(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcInventory_MarkDirty",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->MarkDirty((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_TestConstraints(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    char *arg2 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcInventory_TestConstraints",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (bool)(arg1)->TestConstraints((char const *)arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_Dump(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcInventory_Dump",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->Dump();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_SetSpace(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    iCelInventorySpace *arg2 = (iCelInventorySpace *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcInventory_SetSpace",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelInventorySpace, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetSpace(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcInventory_GetSpace(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    iCelInventorySpace *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcInventory_GetSpace",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iCelInventorySpace *)(arg1)->GetSpace();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iCelInventorySpace, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcInventory(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcInventory *arg1 = (iPcInventory *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcInventory",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcInventory_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcInventory, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateInventory(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcInventory *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateInventory",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcInventory *)celCreateInventory(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcInventory, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetInventory(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcInventory *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetInventory",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcInventory *)celGetInventory(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcInventory, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcInventory(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcInventory *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcInventory",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcInventory *)scfQuery_iPcInventory(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcInventory, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCharacteristics_SetCharacteristic(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCharacteristics *arg1 = (iPcCharacteristics *) 0 ;
    char *arg2 = (char *) 0 ;
    float arg3 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcCharacteristics_SetCharacteristic",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCharacteristics, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    result = (bool)(arg1)->SetCharacteristic((char const *)arg2,arg3);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCharacteristics_SetInheritedCharacteristic(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCharacteristics *arg1 = (iPcCharacteristics *) 0 ;
    char *arg2 = (char *) 0 ;
    float arg3 ;
    float arg4 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcCharacteristics_SetInheritedCharacteristic",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCharacteristics, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    {
        arg3 = (float)(SWIG_As_float(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (float)(SWIG_As_float(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    result = (bool)(arg1)->SetInheritedCharacteristic((char const *)arg2,arg3,arg4);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCharacteristics_GetCharacteristic(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCharacteristics *arg1 = (iPcCharacteristics *) 0 ;
    char *arg2 = (char *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcCharacteristics_GetCharacteristic",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCharacteristics, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (float)((iPcCharacteristics const *)arg1)->GetCharacteristic((char const *)arg2);
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCharacteristics_GetLocalCharacteristic(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCharacteristics *arg1 = (iPcCharacteristics *) 0 ;
    char *arg2 = (char *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcCharacteristics_GetLocalCharacteristic",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCharacteristics, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (float)((iPcCharacteristics const *)arg1)->GetLocalCharacteristic((char const *)arg2);
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCharacteristics_GetInheritedCharacteristic(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCharacteristics *arg1 = (iPcCharacteristics *) 0 ;
    char *arg2 = (char *) 0 ;
    float result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcCharacteristics_GetInheritedCharacteristic",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCharacteristics, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (float)((iPcCharacteristics const *)arg1)->GetInheritedCharacteristic((char const *)arg2);
    
    {
        resultobj = SWIG_From_float((float)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCharacteristics_ClearCharacteristic(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCharacteristics *arg1 = (iPcCharacteristics *) 0 ;
    char *arg2 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcCharacteristics_ClearCharacteristic",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCharacteristics, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (bool)(arg1)->ClearCharacteristic((char const *)arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCharacteristics_HasCharacteristic(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCharacteristics *arg1 = (iPcCharacteristics *) 0 ;
    char *arg2 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcCharacteristics_HasCharacteristic",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCharacteristics, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (bool)((iPcCharacteristics const *)arg1)->HasCharacteristic((char const *)arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCharacteristics_ClearAll(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCharacteristics *arg1 = (iPcCharacteristics *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcCharacteristics_ClearAll",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCharacteristics, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)(arg1)->ClearAll();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCharacteristics_AddToInventory(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCharacteristics *arg1 = (iPcCharacteristics *) 0 ;
    iPcInventory *arg2 = (iPcInventory *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcCharacteristics_AddToInventory",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCharacteristics, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->AddToInventory(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCharacteristics_RemoveFromInventory(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCharacteristics *arg1 = (iPcCharacteristics *) 0 ;
    iPcInventory *arg2 = (iPcInventory *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcCharacteristics_RemoveFromInventory",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCharacteristics, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iPcInventory, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->RemoveFromInventory(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCharacteristics_MarkDirty(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCharacteristics *arg1 = (iPcCharacteristics *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcCharacteristics_MarkDirty",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCharacteristics, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->MarkDirty((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCharacteristics_TestConstraints(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCharacteristics *arg1 = (iPcCharacteristics *) 0 ;
    char *arg2 = (char *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcCharacteristics_TestConstraints",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCharacteristics, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    result = (bool)(arg1)->TestConstraints((char const *)arg2);
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcCharacteristics_Dump(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCharacteristics *arg1 = (iPcCharacteristics *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcCharacteristics_Dump",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCharacteristics, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->Dump();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcCharacteristics(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcCharacteristics *arg1 = (iPcCharacteristics *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcCharacteristics",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcCharacteristics, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcCharacteristics_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcCharacteristics, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateCharacteristics(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcCharacteristics *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateCharacteristics",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcCharacteristics *)celCreateCharacteristics(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcCharacteristics, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetCharacteristics(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcCharacteristics *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetCharacteristics",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcCharacteristics *)celGetCharacteristics(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcCharacteristics, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcCharacteristics(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcCharacteristics *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcCharacteristics",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcCharacteristics *)scfQuery_iPcCharacteristics(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcCharacteristics, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcTooltip_SetText(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcTooltip *arg1 = (iPcTooltip *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcTooltip_SetText",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcTooltip, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->SetText((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcTooltip_Show(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcTooltip *arg1 = (iPcTooltip *) 0 ;
    int arg2 ;
    int arg3 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOO:iPcTooltip_Show",&obj0,&obj1,&obj2)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcTooltip, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    (arg1)->Show(arg2,arg3);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcTooltip_Hide(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcTooltip *arg1 = (iPcTooltip *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcTooltip_Hide",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcTooltip, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    (arg1)->Hide();
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcTooltip_IsVisible(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcTooltip *arg1 = (iPcTooltip *) 0 ;
    bool result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcTooltip_IsVisible",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcTooltip, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (bool)((iPcTooltip const *)arg1)->IsVisible();
    
    {
        resultobj = SWIG_From_bool((bool)(result)); 
    }
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcTooltip_SetTextColor(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcTooltip *arg1 = (iPcTooltip *) 0 ;
    int arg2 ;
    int arg3 ;
    int arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcTooltip_SetTextColor",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcTooltip, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (int)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    (arg1)->SetTextColor(arg2,arg3,arg4);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcTooltip_SetBackgroundColor(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcTooltip *arg1 = (iPcTooltip *) 0 ;
    int arg2 ;
    int arg3 ;
    int arg4 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    PyObject * obj2 = 0 ;
    PyObject * obj3 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOOO:iPcTooltip_SetBackgroundColor",&obj0,&obj1,&obj2,&obj3)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcTooltip, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (int)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    {
        arg3 = (int)(SWIG_As_int(obj2)); 
        if (SWIG_arg_fail(3)) SWIG_fail;
    }
    {
        arg4 = (int)(SWIG_As_int(obj3)); 
        if (SWIG_arg_fail(4)) SWIG_fail;
    }
    (arg1)->SetBackgroundColor(arg2,arg3,arg4);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcTooltip_SetFont(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcTooltip *arg1 = (iPcTooltip *) 0 ;
    iFont *arg2 = (iFont *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcTooltip_SetFont",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcTooltip, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iFont, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    (arg1)->SetFont(arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcTooltip_SetJustify(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcTooltip *arg1 = (iPcTooltip *) 0 ;
    celTooltipJustify arg2 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcTooltip_SetJustify",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcTooltip, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    {
        arg2 = (celTooltipJustify)(SWIG_As_int(obj1)); 
        if (SWIG_arg_fail(2)) SWIG_fail;
    }
    (arg1)->SetJustify((celTooltipJustify )arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcTooltip(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcTooltip *arg1 = (iPcTooltip *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcTooltip",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcTooltip, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcTooltip_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcTooltip, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateToolTip(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcTooltip *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateToolTip",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcTooltip *)celCreateToolTip(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcTooltip, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetToolTip(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcTooltip *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetToolTip",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcTooltip *)celGetToolTip(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcTooltip, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcTooltip(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcTooltip *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcTooltip",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcTooltip *)scfQuery_iPcTooltip(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcTooltip, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcSoundListener_GetSoundListener(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcSoundListener *arg1 = (iPcSoundListener *) 0 ;
    iSndSysListener *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcSoundListener_GetSoundListener",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcSoundListener, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iSndSysListener *)(arg1)->GetSoundListener();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iSndSysListener, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcSoundListener(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcSoundListener *arg1 = (iPcSoundListener *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcSoundListener",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcSoundListener, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcSoundListener_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcSoundListener, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_iPcSoundSource_GetSoundSource(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcSoundSource *arg1 = (iPcSoundSource *) 0 ;
    iSndSysSource *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcSoundSource_GetSoundSource",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcSoundSource, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iSndSysSource *)(arg1)->GetSoundSource();
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iSndSysSource, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcSoundSource_SetSoundName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcSoundSource *arg1 = (iPcSoundSource *) 0 ;
    char *arg2 = (char *) 0 ;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:iPcSoundSource_SetSoundName",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcSoundSource, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    if (!SWIG_AsCharPtr(obj1, (char**)&arg2)) {
        SWIG_arg_fail(2);SWIG_fail;
    }
    (arg1)->SetSoundName((char const *)arg2);
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_iPcSoundSource_GetSoundName(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcSoundSource *arg1 = (iPcSoundSource *) 0 ;
    char *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:iPcSoundSource_GetSoundName",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcSoundSource, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (char *)((iPcSoundSource const *)arg1)->GetSoundName();
    
    resultobj = SWIG_FromCharPtr(result);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_delete_iPcSoundSource(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iPcSoundSource *arg1 = (iPcSoundSource *) 0 ;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:delete_iPcSoundSource",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iPcSoundSource, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    delete arg1;
    
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
    fail:
    return NULL;
}


static PyObject * iPcSoundSource_swigregister(PyObject *, PyObject *args) {
    PyObject *obj;
    if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
    SWIG_TypeClientData(SWIGTYPE_p_iPcSoundSource, obj);
    Py_INCREF(obj);
    return Py_BuildValue((char *)"");
}
static PyObject *_wrap_celCreateSoundSource(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcSoundSource *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateSoundSource",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcSoundSource *)celCreateSoundSource(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcSoundSource, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetSoundSource(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcSoundSource *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetSoundSource",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcSoundSource *)celGetSoundSource(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcSoundSource, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcSoundSource(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcSoundSource *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcSoundSource",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcSoundSource *)scfQuery_iPcSoundSource(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcSoundSource, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celCreateSoundListener(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPlLayer *arg1 = (iCelPlLayer *) 0 ;
    iCelEntity *arg2 = (iCelEntity *) 0 ;
    iPcSoundListener *result;
    PyObject * obj0 = 0 ;
    PyObject * obj1 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:celCreateSoundListener",&obj0,&obj1)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPlLayer, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(2)) SWIG_fail;
    result = (iPcSoundListener *)celCreateSoundListener(arg1,arg2);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcSoundListener, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_celGetSoundListener(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelEntity *arg1 = (iCelEntity *) 0 ;
    iPcSoundListener *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:celGetSoundListener",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelEntity, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcSoundListener *)celGetSoundListener(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcSoundListener, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyObject *_wrap_scfQuery_iPcSoundListener(PyObject *, PyObject *args) {
    PyObject *resultobj;
    iCelPropertyClass *arg1 = (iCelPropertyClass *) 0 ;
    iPcSoundListener *result;
    PyObject * obj0 = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:scfQuery_iPcSoundListener",&obj0)) goto fail;
    SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_iCelPropertyClass, SWIG_POINTER_EXCEPTION | 0);
    if (SWIG_arg_fail(1)) SWIG_fail;
    result = (iPcSoundListener *)scfQuery_iPcSoundListener(arg1);
    
    resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_iPcSoundListener, 0);
    return resultobj;
    fail:
    return NULL;
}


static PyMethodDef SwigMethods[] = {
	 { (char *)"celInitializer_SetupCelPluginDirs", _wrap_celInitializer_SetupCelPluginDirs, METH_VARARGS, NULL},
	 { (char *)"celInitializer__RequestPlugins", _wrap_celInitializer__RequestPlugins, METH_VARARGS, NULL},
	 { (char *)"new_celInitializer", _wrap_new_celInitializer, METH_VARARGS, NULL},
	 { (char *)"delete_celInitializer", _wrap_delete_celInitializer, METH_VARARGS, NULL},
	 { (char *)"celInitializer_swigregister", celInitializer_swigregister, METH_VARARGS, NULL},
	 { (char *)"iCelNewEntityCallback_NewEntity", _wrap_iCelNewEntityCallback_NewEntity, METH_VARARGS, NULL},
	 { (char *)"delete_iCelNewEntityCallback", _wrap_delete_iCelNewEntityCallback, METH_VARARGS, NULL},
	 { (char *)"iCelNewEntityCallback_swigregister", iCelNewEntityCallback_swigregister, METH_VARARGS, NULL},
	 { (char *)"iCelEntityRemoveCallback_RemoveEntity", _wrap_iCelEntityRemoveCallback_RemoveEntity, METH_VARARGS, NULL},
	 { (char *)"delete_iCelEntityRemoveCallback", _wrap_delete_iCelEntityRemoveCallback, METH_VARARGS, NULL},
	 { (char *)"iCelEntityRemoveCallback_swigregister", iCelEntityRemoveCallback_swigregister, METH_VARARGS, NULL},
	 { (char *)"iCelTimerListener_TickEveryFrame", _wrap_iCelTimerListener_TickEveryFrame, METH_VARARGS, NULL},
	 { (char *)"iCelTimerListener_TickOnce", _wrap_iCelTimerListener_TickOnce, METH_VARARGS, NULL},
	 { (char *)"delete_iCelTimerListener", _wrap_delete_iCelTimerListener, METH_VARARGS, NULL},
	 { (char *)"iCelTimerListener_swigregister", iCelTimerListener_swigregister, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_CreateEntityInScope", _wrap_iCelPlLayer_CreateEntityInScope, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_RemoveEntity", _wrap_iCelPlLayer_RemoveEntity, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_RemoveEntities", _wrap_iCelPlLayer_RemoveEntities, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_CreateEntityTemplate", _wrap_iCelPlLayer_CreateEntityTemplate, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_RemoveEntityTemplate", _wrap_iCelPlLayer_RemoveEntityTemplate, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_RemoveEntityTemplates", _wrap_iCelPlLayer_RemoveEntityTemplates, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_FindEntityTemplate", _wrap_iCelPlLayer_FindEntityTemplate, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_CreateEntity", _wrap_iCelPlLayer_CreateEntity, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_CreateMessage", _wrap_iCelPlLayer_CreateMessage, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_CreateDataBuffer", _wrap_iCelPlLayer_CreateDataBuffer, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_AttachEntity", _wrap_iCelPlLayer_AttachEntity, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_UnattachEntity", _wrap_iCelPlLayer_UnattachEntity, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_GetEntity", _wrap_iCelPlLayer_GetEntity, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_GetEntityCount", _wrap_iCelPlLayer_GetEntityCount, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_GetEntityByIndex", _wrap_iCelPlLayer_GetEntityByIndex, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_FindEntity", _wrap_iCelPlLayer_FindEntity, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_GetBehaviour", _wrap_iCelPlLayer_GetBehaviour, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_FindAttachedEntity", _wrap_iCelPlLayer_FindAttachedEntity, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_FindNearbyEntities", _wrap_iCelPlLayer_FindNearbyEntities, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_GetHitEntity", _wrap_iCelPlLayer_GetHitEntity, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_CreateEmptyEntityList", _wrap_iCelPlLayer_CreateEmptyEntityList, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_CreateEntityTracker", _wrap_iCelPlLayer_CreateEntityTracker, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_FindEntityTracker", _wrap_iCelPlLayer_FindEntityTracker, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_RemoveEntityTracker", _wrap_iCelPlLayer_RemoveEntityTracker, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_SetEntityAddonAllowed", _wrap_iCelPlLayer_SetEntityAddonAllowed, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_IsEntityAddonAllowed", _wrap_iCelPlLayer_IsEntityAddonAllowed, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_LoadPropertyClassFactory", _wrap_iCelPlLayer_LoadPropertyClassFactory, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_RegisterPropertyClassFactory", _wrap_iCelPlLayer_RegisterPropertyClassFactory, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_UnregisterPropertyClassFactory", _wrap_iCelPlLayer_UnregisterPropertyClassFactory, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_GetPropertyClassFactoryCount", _wrap_iCelPlLayer_GetPropertyClassFactoryCount, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_GetPropertyClassFactory", _wrap_iCelPlLayer_GetPropertyClassFactory, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_FindPropertyClassFactory", _wrap_iCelPlLayer_FindPropertyClassFactory, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_CreatePropertyClass", _wrap_iCelPlLayer_CreatePropertyClass, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_CreateTaggedPropertyClass", _wrap_iCelPlLayer_CreateTaggedPropertyClass, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_RegisterBehaviourLayer", _wrap_iCelPlLayer_RegisterBehaviourLayer, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_UnregisterBehaviourLayer", _wrap_iCelPlLayer_UnregisterBehaviourLayer, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_GetBehaviourLayerCount", _wrap_iCelPlLayer_GetBehaviourLayerCount, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_GetBehaviourLayer", _wrap_iCelPlLayer_GetBehaviourLayer, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_FindBehaviourLayer", _wrap_iCelPlLayer_FindBehaviourLayer, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_Cache", _wrap_iCelPlLayer_Cache, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_Uncache", _wrap_iCelPlLayer_Uncache, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_CleanCache", _wrap_iCelPlLayer_CleanCache, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_FetchStringID", _wrap_iCelPlLayer_FetchStringID, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_FetchString", _wrap_iCelPlLayer_FetchString, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_AddEntityRemoveCallback", _wrap_iCelPlLayer_AddEntityRemoveCallback, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_RemoveEntityRemoveCallback", _wrap_iCelPlLayer_RemoveEntityRemoveCallback, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_AddNewEntityCallback", _wrap_iCelPlLayer_AddNewEntityCallback, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_RemoveNewEntityCallback", _wrap_iCelPlLayer_RemoveNewEntityCallback, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_CallbackEveryFrame", _wrap_iCelPlLayer_CallbackEveryFrame, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_CallbackOnce", _wrap_iCelPlLayer_CallbackOnce, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_RemoveCallbackEveryFrame", _wrap_iCelPlLayer_RemoveCallbackEveryFrame, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_RemoveCallbackOnce", _wrap_iCelPlLayer_RemoveCallbackOnce, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_AddScope", _wrap_iCelPlLayer_AddScope, METH_VARARGS, NULL},
	 { (char *)"delete_iCelPlLayer", _wrap_delete_iCelPlLayer, METH_VARARGS, NULL},
	 { (char *)"iCelPlLayer_swigregister", iCelPlLayer_swigregister, METH_VARARGS, NULL},
	 { (char *)"iCelEntityTracker_GetName", _wrap_iCelEntityTracker_GetName, METH_VARARGS, NULL},
	 { (char *)"iCelEntityTracker_AddEntity", _wrap_iCelEntityTracker_AddEntity, METH_VARARGS, NULL},
	 { (char *)"iCelEntityTracker_RemoveEntity", _wrap_iCelEntityTracker_RemoveEntity, METH_VARARGS, NULL},
	 { (char *)"iCelEntityTracker_RemoveEntities", _wrap_iCelEntityTracker_RemoveEntities, METH_VARARGS, NULL},
	 { (char *)"iCelEntityTracker_FindNearbyEntities", _wrap_iCelEntityTracker_FindNearbyEntities, METH_VARARGS, NULL},
	 { (char *)"delete_iCelEntityTracker", _wrap_delete_iCelEntityTracker, METH_VARARGS, NULL},
	 { (char *)"iCelEntityTracker_swigregister", iCelEntityTracker_swigregister, METH_VARARGS, NULL},
	 { (char *)"csQueryRegistry_iCelPlLayer", _wrap_csQueryRegistry_iCelPlLayer, METH_VARARGS, NULL},
	 { (char *)"iCelEntity_QueryObject", _wrap_iCelEntity_QueryObject, METH_VARARGS, NULL},
	 { (char *)"iCelEntity_GetName", _wrap_iCelEntity_GetName, METH_VARARGS, NULL},
	 { (char *)"iCelEntity_SetName", _wrap_iCelEntity_SetName, METH_VARARGS, NULL},
	 { (char *)"iCelEntity_GetID", _wrap_iCelEntity_GetID, METH_VARARGS, NULL},
	 { (char *)"iCelEntity_SetID", _wrap_iCelEntity_SetID, METH_VARARGS, NULL},
	 { (char *)"iCelEntity_GetPropertyClassList", _wrap_iCelEntity_GetPropertyClassList, METH_VARARGS, NULL},
	 { (char *)"iCelEntity_SetBehaviour", _wrap_iCelEntity_SetBehaviour, METH_VARARGS, NULL},
	 { (char *)"iCelEntity_GetBehaviour", _wrap_iCelEntity_GetBehaviour, METH_VARARGS, NULL},
	 { (char *)"iCelEntity_CreateBehaviour", _wrap_iCelEntity_CreateBehaviour, METH_VARARGS, NULL},
	 { (char *)"delete_iCelEntity", _wrap_delete_iCelEntity, METH_VARARGS, NULL},
	 { (char *)"iCelEntity_swigregister", iCelEntity_swigregister, METH_VARARGS, NULL},
	 { (char *)"iCelEntityList_GetCount", _wrap_iCelEntityList_GetCount, METH_VARARGS, NULL},
	 { (char *)"iCelEntityList_Get", _wrap_iCelEntityList_Get, METH_VARARGS, NULL},
	 { (char *)"iCelEntityList_Add", _wrap_iCelEntityList_Add, METH_VARARGS, NULL},
	 { (char *)"iCelEntityList_Remove", _wrap_iCelEntityList_Remove, METH_VARARGS, NULL},
	 { (char *)"iCelEntityList_RemoveAll", _wrap_iCelEntityList_RemoveAll, METH_VARARGS, NULL},
	 { (char *)"iCelEntityList_Find", _wrap_iCelEntityList_Find, METH_VARARGS, NULL},
	 { (char *)"iCelEntityList_FindByName", _wrap_iCelEntityList_FindByName, METH_VARARGS, NULL},
	 { (char *)"delete_iCelEntityList", _wrap_delete_iCelEntityList, METH_VARARGS, NULL},
	 { (char *)"iCelEntityList_swigregister", iCelEntityList_swigregister, METH_VARARGS, NULL},
	 { (char *)"celRegisterPCFactory", _wrap_celRegisterPCFactory, METH_VARARGS, NULL},
	 { (char *)"celCreateEntity", _wrap_celCreateEntity, METH_VARARGS, NULL},
	 { (char *)"scfQueryInterface_iCelEntity", _wrap_scfQueryInterface_iCelEntity, METH_VARARGS, NULL},
	 { (char *)"celFindNearbyEntities", _wrap_celFindNearbyEntities, METH_VARARGS, NULL},
	 { (char *)"iCelBlLayer_GetName", _wrap_iCelBlLayer_GetName, METH_VARARGS, NULL},
	 { (char *)"iCelBlLayer_CreateBehaviour", _wrap_iCelBlLayer_CreateBehaviour, METH_VARARGS, NULL},
	 { (char *)"delete_iCelBlLayer", _wrap_delete_iCelBlLayer, METH_VARARGS, NULL},
	 { (char *)"iCelBlLayer_swigregister", iCelBlLayer_swigregister, METH_VARARGS, NULL},
	 { (char *)"csQueryRegistry_iCelBlLayer", _wrap_csQueryRegistry_iCelBlLayer, METH_VARARGS, NULL},
	 { (char *)"iCelParameterBlock_GetParameterCount", _wrap_iCelParameterBlock_GetParameterCount, METH_VARARGS, NULL},
	 { (char *)"iCelParameterBlock_GetParameter", _wrap_iCelParameterBlock_GetParameter, METH_VARARGS, NULL},
	 { (char *)"iCelParameterBlock_GetParameterValue", _wrap_iCelParameterBlock_GetParameterValue, METH_VARARGS, NULL},
	 { (char *)"delete_iCelParameterBlock", _wrap_delete_iCelParameterBlock, METH_VARARGS, NULL},
	 { (char *)"iCelParameterBlock_swigregister", iCelParameterBlock_swigregister, METH_VARARGS, NULL},
	 { (char *)"iCelBehaviour_GetName", _wrap_iCelBehaviour_GetName, METH_VARARGS, NULL},
	 { (char *)"iCelBehaviour_GetBehaviourLayer", _wrap_iCelBehaviour_GetBehaviourLayer, METH_VARARGS, NULL},
	 { (char *)"iCelBehaviour_SendMessage", _wrap_iCelBehaviour_SendMessage, METH_VARARGS, NULL},
	 { (char *)"iCelBehaviour_GetInternalObject", _wrap_iCelBehaviour_GetInternalObject, METH_VARARGS, NULL},
	 { (char *)"iCelBehaviour_GetPythonObject", _wrap_iCelBehaviour_GetPythonObject, METH_VARARGS, NULL},
	 { (char *)"delete_iCelBehaviour", _wrap_delete_iCelBehaviour, METH_VARARGS, NULL},
	 { (char *)"iCelBehaviour_swigregister", iCelBehaviour_swigregister, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_GetName", _wrap_iCelPropertyClass_GetName, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_SetTag", _wrap_iCelPropertyClass_SetTag, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_GetTag", _wrap_iCelPropertyClass_GetTag, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_GetEntity", _wrap_iCelPropertyClass_GetEntity, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_SetEntity", _wrap_iCelPropertyClass_SetEntity, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_SaveFirstPass", _wrap_iCelPropertyClass_SaveFirstPass, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_LoadFirstPass", _wrap_iCelPropertyClass_LoadFirstPass, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_Save", _wrap_iCelPropertyClass_Save, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_Load", _wrap_iCelPropertyClass_Load, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_AddPropertyChangeCallback", _wrap_iCelPropertyClass_AddPropertyChangeCallback, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_RemovePropertyChangeCallback", _wrap_iCelPropertyClass_RemovePropertyChangeCallback, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_GetPropertyOrActionType", _wrap_iCelPropertyClass_GetPropertyOrActionType, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_IsPropertyReadOnly", _wrap_iCelPropertyClass_IsPropertyReadOnly, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_GetPropertyLong", _wrap_iCelPropertyClass_GetPropertyLong, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_GetPropertyFloat", _wrap_iCelPropertyClass_GetPropertyFloat, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_GetPropertyBool", _wrap_iCelPropertyClass_GetPropertyBool, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_GetPropertyString", _wrap_iCelPropertyClass_GetPropertyString, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_GetPropertyVector", _wrap_iCelPropertyClass_GetPropertyVector, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_GetPropertyColor", _wrap_iCelPropertyClass_GetPropertyColor, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_GetPropertyPClass", _wrap_iCelPropertyClass_GetPropertyPClass, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_GetPropertyEntity", _wrap_iCelPropertyClass_GetPropertyEntity, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_PerformAction", _wrap_iCelPropertyClass_PerformAction, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_GetPropertyAndActionCount", _wrap_iCelPropertyClass_GetPropertyAndActionCount, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_GetPropertyOrActionID", _wrap_iCelPropertyClass_GetPropertyOrActionID, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_GetPropertyOrActionDescription", _wrap_iCelPropertyClass_GetPropertyOrActionDescription, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_PropertyClassesHaveChanged", _wrap_iCelPropertyClass_PropertyClassesHaveChanged, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_GetPersistentData", _wrap_iCelPropertyClass_GetPersistentData, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_SetPersistentData", _wrap_iCelPropertyClass_SetPersistentData, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_SetPropertyLong", _wrap_iCelPropertyClass_SetPropertyLong, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_SetPropertyFloat", _wrap_iCelPropertyClass_SetPropertyFloat, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_SetPropertyBool", _wrap_iCelPropertyClass_SetPropertyBool, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_SetPropertyString", _wrap_iCelPropertyClass_SetPropertyString, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_SetPropertyVector3", _wrap_iCelPropertyClass_SetPropertyVector3, METH_VARARGS, NULL},
	 { (char *)"delete_iCelPropertyClass", _wrap_delete_iCelPropertyClass, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClass_swigregister", iCelPropertyClass_swigregister, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClassList_GetCount", _wrap_iCelPropertyClassList_GetCount, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClassList_Get", _wrap_iCelPropertyClassList_Get, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClassList_Add", _wrap_iCelPropertyClassList_Add, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClassList_Remove", _wrap_iCelPropertyClassList_Remove, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClassList_RemoveByInterface", _wrap_iCelPropertyClassList_RemoveByInterface, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClassList_RemoveByInterfaceAndTag", _wrap_iCelPropertyClassList_RemoveByInterfaceAndTag, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClassList_RemoveAll", _wrap_iCelPropertyClassList_RemoveAll, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClassList_Find", _wrap_iCelPropertyClassList_Find, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClassList_FindByName", _wrap_iCelPropertyClassList_FindByName, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClassList_FindByNameAndTag", _wrap_iCelPropertyClassList_FindByNameAndTag, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClassList_FindByInterface", _wrap_iCelPropertyClassList_FindByInterface, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClassList_FindByInterfaceAndTag", _wrap_iCelPropertyClassList_FindByInterfaceAndTag, METH_VARARGS, NULL},
	 { (char *)"delete_iCelPropertyClassList", _wrap_delete_iCelPropertyClassList, METH_VARARGS, NULL},
	 { (char *)"iCelPropertyClassList_swigregister", iCelPropertyClassList_swigregister, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_SetDynamicSystem", _wrap_iPcMechanicsSystem_SetDynamicSystem, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_GetDynamicSystem", _wrap_iPcMechanicsSystem_GetDynamicSystem, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_SetStepTime", _wrap_iPcMechanicsSystem_SetStepTime, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_GetStepTime", _wrap_iPcMechanicsSystem_GetStepTime, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_SetGravity", _wrap_iPcMechanicsSystem_SetGravity, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_GetGravity", _wrap_iPcMechanicsSystem_GetGravity, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_AddForceDuration", _wrap_iPcMechanicsSystem_AddForceDuration, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_AddForceFrame", _wrap_iPcMechanicsSystem_AddForceFrame, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_AddForceTagged", _wrap_iPcMechanicsSystem_AddForceTagged, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_RemoveForceTagged", _wrap_iPcMechanicsSystem_RemoveForceTagged, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_ClearForces", _wrap_iPcMechanicsSystem_ClearForces, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_ClearAllForces", _wrap_iPcMechanicsSystem_ClearAllForces, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_CreateBody", _wrap_iPcMechanicsSystem_CreateBody, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_RemoveBody", _wrap_iPcMechanicsSystem_RemoveBody, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_AddBodyToGroup", _wrap_iPcMechanicsSystem_AddBodyToGroup, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_RemoveBodyFromGroup", _wrap_iPcMechanicsSystem_RemoveBodyFromGroup, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_CreateJoint", _wrap_iPcMechanicsSystem_CreateJoint, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_RemoveJoint", _wrap_iPcMechanicsSystem_RemoveJoint, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_DisableStepFast", _wrap_iPcMechanicsSystem_DisableStepFast, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_EnableStepFast", _wrap_iPcMechanicsSystem_EnableStepFast, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_EnableQuickStep", _wrap_iPcMechanicsSystem_EnableQuickStep, METH_VARARGS, NULL},
	 { (char *)"delete_iPcMechanicsSystem", _wrap_delete_iPcMechanicsSystem, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsSystem_swigregister", iPcMechanicsSystem_swigregister, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_SetMesh", _wrap_iPcMechanicsObject_SetMesh, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_GetMesh", _wrap_iPcMechanicsObject_GetMesh, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_SetLight", _wrap_iPcMechanicsObject_SetLight, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_GetLight", _wrap_iPcMechanicsObject_GetLight, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_SetCamera", _wrap_iPcMechanicsObject_SetCamera, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_GetCamera", _wrap_iPcMechanicsObject_GetCamera, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_SetMechanicsSystem", _wrap_iPcMechanicsObject_SetMechanicsSystem, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_GetMechanicsSystem", _wrap_iPcMechanicsObject_GetMechanicsSystem, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_GetBody", _wrap_iPcMechanicsObject_GetBody, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_SetFriction", _wrap_iPcMechanicsObject_SetFriction, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_SetMass", _wrap_iPcMechanicsObject_SetMass, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_SetElasticity", _wrap_iPcMechanicsObject_SetElasticity, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_SetDensity", _wrap_iPcMechanicsObject_SetDensity, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_SetSoftness", _wrap_iPcMechanicsObject_SetSoftness, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_SetLift", _wrap_iPcMechanicsObject_SetLift, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_SetDrag", _wrap_iPcMechanicsObject_SetDrag, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_GetFriction", _wrap_iPcMechanicsObject_GetFriction, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_GetMass", _wrap_iPcMechanicsObject_GetMass, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_GetElasticity", _wrap_iPcMechanicsObject_GetElasticity, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_GetDensity", _wrap_iPcMechanicsObject_GetDensity, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_GetSoftness", _wrap_iPcMechanicsObject_GetSoftness, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_GetLift", _wrap_iPcMechanicsObject_GetLift, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_GetDrag", _wrap_iPcMechanicsObject_GetDrag, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_SetLinearVelocity", _wrap_iPcMechanicsObject_SetLinearVelocity, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_SetAngularVelocity", _wrap_iPcMechanicsObject_SetAngularVelocity, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_GetLinearVelocity", _wrap_iPcMechanicsObject_GetLinearVelocity, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_GetAngularVelocity", _wrap_iPcMechanicsObject_GetAngularVelocity, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_MakeStatic", _wrap_iPcMechanicsObject_MakeStatic, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_IsStatic", _wrap_iPcMechanicsObject_IsStatic, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_AttachColliderSphere", _wrap_iPcMechanicsObject_AttachColliderSphere, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_AttachColliderCylinder", _wrap_iPcMechanicsObject_AttachColliderCylinder, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_AttachColliderBox", _wrap_iPcMechanicsObject_AttachColliderBox, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_AttachColliderPlane", _wrap_iPcMechanicsObject_AttachColliderPlane, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_AttachColliderMesh", _wrap_iPcMechanicsObject_AttachColliderMesh, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_AddForceOnce", _wrap_iPcMechanicsObject_AddForceOnce, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_AddForceDuration", _wrap_iPcMechanicsObject_AddForceDuration, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_AddForceFrame", _wrap_iPcMechanicsObject_AddForceFrame, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_AddForceTagged", _wrap_iPcMechanicsObject_AddForceTagged, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_RemoveForceTagged", _wrap_iPcMechanicsObject_RemoveForceTagged, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_ClearForces", _wrap_iPcMechanicsObject_ClearForces, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_AddToGroup", _wrap_iPcMechanicsObject_AddToGroup, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_RemoveFromGroup", _wrap_iPcMechanicsObject_RemoveFromGroup, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_CreateJoint", _wrap_iPcMechanicsObject_CreateJoint, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_LocalToWorld", _wrap_iPcMechanicsObject_LocalToWorld, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_WorldToLocal", _wrap_iPcMechanicsObject_WorldToLocal, METH_VARARGS, NULL},
	 { (char *)"delete_iPcMechanicsObject", _wrap_delete_iPcMechanicsObject, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsObject_swigregister", iPcMechanicsObject_swigregister, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsJoint_GetJoint", _wrap_iPcMechanicsJoint_GetJoint, METH_VARARGS, NULL},
	 { (char *)"delete_iPcMechanicsJoint", _wrap_delete_iPcMechanicsJoint, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsJoint_swigregister", iPcMechanicsJoint_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateMechanicsSystem", _wrap_celCreateMechanicsSystem, METH_VARARGS, NULL},
	 { (char *)"celGetMechanicsSystem", _wrap_celGetMechanicsSystem, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcMechanicsSystem", _wrap_scfQuery_iPcMechanicsSystem, METH_VARARGS, NULL},
	 { (char *)"scfQueryPC_iPcMechanicsSystem", _wrap_scfQueryPC_iPcMechanicsSystem, METH_VARARGS, NULL},
	 { (char *)"celCreateMechanicsObject", _wrap_celCreateMechanicsObject, METH_VARARGS, NULL},
	 { (char *)"celGetMechanicsObject", _wrap_celGetMechanicsObject, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcMechanicsObject", _wrap_scfQuery_iPcMechanicsObject, METH_VARARGS, NULL},
	 { (char *)"scfQueryPC_iPcMechanicsObject", _wrap_scfQueryPC_iPcMechanicsObject, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThruster_SetMechanicsObject", _wrap_iPcMechanicsThruster_SetMechanicsObject, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThruster_GetMechanicsObject", _wrap_iPcMechanicsThruster_GetMechanicsObject, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThruster_SetPosition", _wrap_iPcMechanicsThruster_SetPosition, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThruster_GetPosition", _wrap_iPcMechanicsThruster_GetPosition, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThruster_SetOrientation", _wrap_iPcMechanicsThruster_SetOrientation, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThruster_GetOrientation", _wrap_iPcMechanicsThruster_GetOrientation, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThruster_SetMaxThrust", _wrap_iPcMechanicsThruster_SetMaxThrust, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThruster_GetMaxThrust", _wrap_iPcMechanicsThruster_GetMaxThrust, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThruster_GetThrustForce", _wrap_iPcMechanicsThruster_GetThrustForce, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThruster_AvailableThrust", _wrap_iPcMechanicsThruster_AvailableThrust, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThruster_ThrustChange", _wrap_iPcMechanicsThruster_ThrustChange, METH_VARARGS, NULL},
	 { (char *)"delete_iPcMechanicsThruster", _wrap_delete_iPcMechanicsThruster, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThruster_swigregister", iPcMechanicsThruster_swigregister, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsBalancedGroup_SetType", _wrap_iPcMechanicsBalancedGroup_SetType, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsBalancedGroup_GetType", _wrap_iPcMechanicsBalancedGroup_GetType, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsBalancedGroup_AddThruster", _wrap_iPcMechanicsBalancedGroup_AddThruster, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsBalancedGroup_RemoveThruster", _wrap_iPcMechanicsBalancedGroup_RemoveThruster, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsBalancedGroup_GetThruster", _wrap_iPcMechanicsBalancedGroup_GetThruster, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsBalancedGroup_AvailableThrust", _wrap_iPcMechanicsBalancedGroup_AvailableThrust, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsBalancedGroup_AvailableThrustForce", _wrap_iPcMechanicsBalancedGroup_AvailableThrustForce, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsBalancedGroup_ChangeThrust", _wrap_iPcMechanicsBalancedGroup_ChangeThrust, METH_VARARGS, NULL},
	 { (char *)"delete_iPcMechanicsBalancedGroup", _wrap_delete_iPcMechanicsBalancedGroup, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsBalancedGroup_swigregister", iPcMechanicsBalancedGroup_swigregister, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThrusterController_SetMechanicsObject", _wrap_iPcMechanicsThrusterController_SetMechanicsObject, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThrusterController_GetMechanicsObject", _wrap_iPcMechanicsThrusterController_GetMechanicsObject, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThrusterController_AddAxis", _wrap_iPcMechanicsThrusterController_AddAxis, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThrusterController_GetAxis", _wrap_iPcMechanicsThrusterController_GetAxis, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThrusterController_GetAxisType", _wrap_iPcMechanicsThrusterController_GetAxisType, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThrusterController_GetAxisVelocity", _wrap_iPcMechanicsThrusterController_GetAxisVelocity, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThrusterController_GetAxisMaxForce", _wrap_iPcMechanicsThrusterController_GetAxisMaxForce, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThrusterController_GetAxisMaxThrust", _wrap_iPcMechanicsThrusterController_GetAxisMaxThrust, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThrusterController_AddBalancedGroup", _wrap_iPcMechanicsThrusterController_AddBalancedGroup, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThrusterController_RemoveBalancedGroup", _wrap_iPcMechanicsThrusterController_RemoveBalancedGroup, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThrusterController_ApplyThrust", _wrap_iPcMechanicsThrusterController_ApplyThrust, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThrusterController_CancelThrust", _wrap_iPcMechanicsThrusterController_CancelThrust, METH_VARARGS, NULL},
	 { (char *)"delete_iPcMechanicsThrusterController", _wrap_delete_iPcMechanicsThrusterController, METH_VARARGS, NULL},
	 { (char *)"iPcMechanicsThrusterController_swigregister", iPcMechanicsThrusterController_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateMechanicsThrusterReactionary", _wrap_celCreateMechanicsThrusterReactionary, METH_VARARGS, NULL},
	 { (char *)"celGetMechanicsThrusterReactionary", _wrap_celGetMechanicsThrusterReactionary, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcMechanicsThruster", _wrap_scfQuery_iPcMechanicsThruster, METH_VARARGS, NULL},
	 { (char *)"scfQueryPC_iPcMechanicsThruster", _wrap_scfQueryPC_iPcMechanicsThruster, METH_VARARGS, NULL},
	 { (char *)"celCreateMechanicsBalancedGroup", _wrap_celCreateMechanicsBalancedGroup, METH_VARARGS, NULL},
	 { (char *)"celGetMechanicsBalancedGroup", _wrap_celGetMechanicsBalancedGroup, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcMechanicsBalancedGroup", _wrap_scfQuery_iPcMechanicsBalancedGroup, METH_VARARGS, NULL},
	 { (char *)"scfQueryPC_iPcMechanicsBalancedGroup", _wrap_scfQueryPC_iPcMechanicsBalancedGroup, METH_VARARGS, NULL},
	 { (char *)"celCreateMechanicsThrusterController", _wrap_celCreateMechanicsThrusterController, METH_VARARGS, NULL},
	 { (char *)"celGetMechanicsThrusterController", _wrap_celGetMechanicsThrusterController, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcMechanicsThrusterController", _wrap_scfQuery_iPcMechanicsThrusterController, METH_VARARGS, NULL},
	 { (char *)"scfQueryPC_iPcMechanicsThrusterController", _wrap_scfQueryPC_iPcMechanicsThrusterController, METH_VARARGS, NULL},
	 { (char *)"iBillboardLayer_GetOffset", _wrap_iBillboardLayer_GetOffset, METH_VARARGS, NULL},
	 { (char *)"iBillboardLayer_SetOffset", _wrap_iBillboardLayer_SetOffset, METH_VARARGS, NULL},
	 { (char *)"iBillboardLayer_Move", _wrap_iBillboardLayer_Move, METH_VARARGS, NULL},
	 { (char *)"iBillboardLayer_GetName", _wrap_iBillboardLayer_GetName, METH_VARARGS, NULL},
	 { (char *)"delete_iBillboardLayer", _wrap_delete_iBillboardLayer, METH_VARARGS, NULL},
	 { (char *)"iBillboardLayer_swigregister", iBillboardLayer_swigregister, METH_VARARGS, NULL},
	 { (char *)"iBillboardEventHandler_Select", _wrap_iBillboardEventHandler_Select, METH_VARARGS, NULL},
	 { (char *)"iBillboardEventHandler_MouseMove", _wrap_iBillboardEventHandler_MouseMove, METH_VARARGS, NULL},
	 { (char *)"iBillboardEventHandler_Unselect", _wrap_iBillboardEventHandler_Unselect, METH_VARARGS, NULL},
	 { (char *)"iBillboardEventHandler_DoubleClick", _wrap_iBillboardEventHandler_DoubleClick, METH_VARARGS, NULL},
	 { (char *)"delete_iBillboardEventHandler", _wrap_delete_iBillboardEventHandler, METH_VARARGS, NULL},
	 { (char *)"iBillboardEventHandler_swigregister", iBillboardEventHandler_swigregister, METH_VARARGS, NULL},
	 { (char *)"iBillboard_GetName", _wrap_iBillboard_GetName, METH_VARARGS, NULL},
	 { (char *)"iBillboard_GetFlags", _wrap_iBillboard_GetFlags, METH_VARARGS, NULL},
	 { (char *)"iBillboard_SetMaterialName", _wrap_iBillboard_SetMaterialName, METH_VARARGS, NULL},
	 { (char *)"iBillboard_SetMaterialNameFast", _wrap_iBillboard_SetMaterialNameFast, METH_VARARGS, NULL},
	 { (char *)"iBillboard_GetMaterialName", _wrap_iBillboard_GetMaterialName, METH_VARARGS, NULL},
	 { (char *)"iBillboard_SetSize", _wrap_iBillboard_SetSize, METH_VARARGS, NULL},
	 { (char *)"iBillboard_GetSize", _wrap_iBillboard_GetSize, METH_VARARGS, NULL},
	 { (char *)"iBillboard_GetImageSize", _wrap_iBillboard_GetImageSize, METH_VARARGS, NULL},
	 { (char *)"iBillboard_SetPosition", _wrap_iBillboard_SetPosition, METH_VARARGS, NULL},
	 { (char *)"iBillboard_MoveToPosition", _wrap_iBillboard_MoveToPosition, METH_VARARGS, NULL},
	 { (char *)"iBillboard_GetPosition", _wrap_iBillboard_GetPosition, METH_VARARGS, NULL},
	 { (char *)"iBillboard_Move", _wrap_iBillboard_Move, METH_VARARGS, NULL},
	 { (char *)"iBillboard_StackTop", _wrap_iBillboard_StackTop, METH_VARARGS, NULL},
	 { (char *)"iBillboard_StackBottom", _wrap_iBillboard_StackBottom, METH_VARARGS, NULL},
	 { (char *)"iBillboard_StackUp", _wrap_iBillboard_StackUp, METH_VARARGS, NULL},
	 { (char *)"iBillboard_StackDown", _wrap_iBillboard_StackDown, METH_VARARGS, NULL},
	 { (char *)"iBillboard_SetUVTopLeft", _wrap_iBillboard_SetUVTopLeft, METH_VARARGS, NULL},
	 { (char *)"iBillboard_GetUVTopLeft", _wrap_iBillboard_GetUVTopLeft, METH_VARARGS, NULL},
	 { (char *)"iBillboard_SetUVBottomRight", _wrap_iBillboard_SetUVBottomRight, METH_VARARGS, NULL},
	 { (char *)"iBillboard_GetUVBottomRight", _wrap_iBillboard_GetUVBottomRight, METH_VARARGS, NULL},
	 { (char *)"iBillboard_SetColor", _wrap_iBillboard_SetColor, METH_VARARGS, NULL},
	 { (char *)"iBillboard_GetColor", _wrap_iBillboard_GetColor, METH_VARARGS, NULL},
	 { (char *)"iBillboard_SetLayer", _wrap_iBillboard_SetLayer, METH_VARARGS, NULL},
	 { (char *)"iBillboard_GetLayer", _wrap_iBillboard_GetLayer, METH_VARARGS, NULL},
	 { (char *)"iBillboard_AddEventHandler", _wrap_iBillboard_AddEventHandler, METH_VARARGS, NULL},
	 { (char *)"iBillboard_RemoveEventHandler", _wrap_iBillboard_RemoveEventHandler, METH_VARARGS, NULL},
	 { (char *)"iBillboard_SetText", _wrap_iBillboard_SetText, METH_VARARGS, NULL},
	 { (char *)"iBillboard_GetText", _wrap_iBillboard_GetText, METH_VARARGS, NULL},
	 { (char *)"iBillboard_SetTextOffset", _wrap_iBillboard_SetTextOffset, METH_VARARGS, NULL},
	 { (char *)"iBillboard_SetTextFont", _wrap_iBillboard_SetTextFont, METH_VARARGS, NULL},
	 { (char *)"iBillboard_SetTextFgColor", _wrap_iBillboard_SetTextFgColor, METH_VARARGS, NULL},
	 { (char *)"iBillboard_ClearTextFgColor", _wrap_iBillboard_ClearTextFgColor, METH_VARARGS, NULL},
	 { (char *)"iBillboard_SetTextBgColor", _wrap_iBillboard_SetTextBgColor, METH_VARARGS, NULL},
	 { (char *)"iBillboard_SetTextBgTransparent", _wrap_iBillboard_SetTextBgTransparent, METH_VARARGS, NULL},
	 { (char *)"iBillboard_ClearTextBgColor", _wrap_iBillboard_ClearTextBgColor, METH_VARARGS, NULL},
	 { (char *)"delete_iBillboard", _wrap_delete_iBillboard, METH_VARARGS, NULL},
	 { (char *)"iBillboard_swigregister", iBillboard_swigregister, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_ScreenToBillboardX", _wrap_iBillboardManager_ScreenToBillboardX, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_ScreenToBillboardY", _wrap_iBillboardManager_ScreenToBillboardY, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_BillboardToScreenX", _wrap_iBillboardManager_BillboardToScreenX, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_BillboardToScreenY", _wrap_iBillboardManager_BillboardToScreenY, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_CreateBillboard", _wrap_iBillboardManager_CreateBillboard, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_FindBillboard", _wrap_iBillboardManager_FindBillboard, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_RemoveBillboard", _wrap_iBillboardManager_RemoveBillboard, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_GetBillboardCount", _wrap_iBillboardManager_GetBillboardCount, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_GetBillboard", _wrap_iBillboardManager_GetBillboard, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_CreateBillboardLayer", _wrap_iBillboardManager_CreateBillboardLayer, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_FindBillboardLayer", _wrap_iBillboardManager_FindBillboardLayer, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_RemoveBillboardLayer", _wrap_iBillboardManager_RemoveBillboardLayer, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_GetBillboardLayerCount", _wrap_iBillboardManager_GetBillboardLayerCount, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_GetBillboardLayer", _wrap_iBillboardManager_GetBillboardLayer, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_RemoveAll", _wrap_iBillboardManager_RemoveAll, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_SetFlags", _wrap_iBillboardManager_SetFlags, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_StackTop", _wrap_iBillboardManager_StackTop, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_StackBottom", _wrap_iBillboardManager_StackBottom, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_StackUp", _wrap_iBillboardManager_StackUp, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_StackDown", _wrap_iBillboardManager_StackDown, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_StackBefore", _wrap_iBillboardManager_StackBefore, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_StackAfter", _wrap_iBillboardManager_StackAfter, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_TestCollision", _wrap_iBillboardManager_TestCollision, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_SetDefaultTextFont", _wrap_iBillboardManager_SetDefaultTextFont, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_SetDefaultTextFgColor", _wrap_iBillboardManager_SetDefaultTextFgColor, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_SetDefaultTextBgColor", _wrap_iBillboardManager_SetDefaultTextBgColor, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_SetDefaultTextBgTransparent", _wrap_iBillboardManager_SetDefaultTextBgTransparent, METH_VARARGS, NULL},
	 { (char *)"delete_iBillboardManager", _wrap_delete_iBillboardManager, METH_VARARGS, NULL},
	 { (char *)"iBillboardManager_swigregister", iBillboardManager_swigregister, METH_VARARGS, NULL},
	 { (char *)"iPcBillboard_SetBillboardName", _wrap_iPcBillboard_SetBillboardName, METH_VARARGS, NULL},
	 { (char *)"iPcBillboard_GetBillboardName", _wrap_iPcBillboard_GetBillboardName, METH_VARARGS, NULL},
	 { (char *)"iPcBillboard_GetBillboard", _wrap_iPcBillboard_GetBillboard, METH_VARARGS, NULL},
	 { (char *)"iPcBillboard_EnableEvents", _wrap_iPcBillboard_EnableEvents, METH_VARARGS, NULL},
	 { (char *)"iPcBillboard_AreEventsEnabled", _wrap_iPcBillboard_AreEventsEnabled, METH_VARARGS, NULL},
	 { (char *)"delete_iPcBillboard", _wrap_delete_iPcBillboard, METH_VARARGS, NULL},
	 { (char *)"iPcBillboard_swigregister", iPcBillboard_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateBillboard", _wrap_celCreateBillboard, METH_VARARGS, NULL},
	 { (char *)"celGetBillboard", _wrap_celGetBillboard, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcBillboard", _wrap_scfQuery_iPcBillboard, METH_VARARGS, NULL},
	 { (char *)"scfQueryPC_iPcBillboard", _wrap_scfQueryPC_iPcBillboard, METH_VARARGS, NULL},
	 { (char *)"iPcRegion_SetWorldFile", _wrap_iPcRegion_SetWorldFile, METH_VARARGS, NULL},
	 { (char *)"iPcRegion_GetWorldDir", _wrap_iPcRegion_GetWorldDir, METH_VARARGS, NULL},
	 { (char *)"iPcRegion_GetWorldFile", _wrap_iPcRegion_GetWorldFile, METH_VARARGS, NULL},
	 { (char *)"iPcRegion_SetRegionName", _wrap_iPcRegion_SetRegionName, METH_VARARGS, NULL},
	 { (char *)"iPcRegion_GetRegionName", _wrap_iPcRegion_GetRegionName, METH_VARARGS, NULL},
	 { (char *)"iPcRegion_CreateEmptySector", _wrap_iPcRegion_CreateEmptySector, METH_VARARGS, NULL},
	 { (char *)"iPcRegion_Load", _wrap_iPcRegion_Load, METH_VARARGS, NULL},
	 { (char *)"iPcRegion_Unload", _wrap_iPcRegion_Unload, METH_VARARGS, NULL},
	 { (char *)"iPcRegion_FindSector", _wrap_iPcRegion_FindSector, METH_VARARGS, NULL},
	 { (char *)"iPcRegion_GetStartSector", _wrap_iPcRegion_GetStartSector, METH_VARARGS, NULL},
	 { (char *)"iPcRegion_GetStartPosition", _wrap_iPcRegion_GetStartPosition, METH_VARARGS, NULL},
	 { (char *)"iPcRegion_PointCamera", _wrap_iPcRegion_PointCamera, METH_VARARGS, NULL},
	 { (char *)"iPcRegion_GetRegion", _wrap_iPcRegion_GetRegion, METH_VARARGS, NULL},
	 { (char *)"iPcRegion_LoadWorld", _wrap_iPcRegion_LoadWorld, METH_VARARGS, NULL},
	 { (char *)"delete_iPcRegion", _wrap_delete_iPcRegion, METH_VARARGS, NULL},
	 { (char *)"iPcRegion_swigregister", iPcRegion_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateRegion", _wrap_celCreateRegion, METH_VARARGS, NULL},
	 { (char *)"Region", _wrap_Region, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcRegion", _wrap_scfQuery_iPcRegion, METH_VARARGS, NULL},
	 { (char *)"scfQueryPC_iPcRegion", _wrap_scfQueryPC_iPcRegion, METH_VARARGS, NULL},
	 { (char *)"iCelMapFile_SetPath", _wrap_iCelMapFile_SetPath, METH_VARARGS, NULL},
	 { (char *)"iCelMapFile_SetFile", _wrap_iCelMapFile_SetFile, METH_VARARGS, NULL},
	 { (char *)"iCelMapFile_GetPath", _wrap_iCelMapFile_GetPath, METH_VARARGS, NULL},
	 { (char *)"iCelMapFile_GetFile", _wrap_iCelMapFile_GetFile, METH_VARARGS, NULL},
	 { (char *)"iCelMapFile_SetSectorName", _wrap_iCelMapFile_SetSectorName, METH_VARARGS, NULL},
	 { (char *)"iCelMapFile_GetSectorName", _wrap_iCelMapFile_GetSectorName, METH_VARARGS, NULL},
	 { (char *)"delete_iCelMapFile", _wrap_delete_iCelMapFile, METH_VARARGS, NULL},
	 { (char *)"iCelMapFile_swigregister", iCelMapFile_swigregister, METH_VARARGS, NULL},
	 { (char *)"iCelRegion_GetName", _wrap_iCelRegion_GetName, METH_VARARGS, NULL},
	 { (char *)"iCelRegion_SetCachePath", _wrap_iCelRegion_SetCachePath, METH_VARARGS, NULL},
	 { (char *)"iCelRegion_GetCachePath", _wrap_iCelRegion_GetCachePath, METH_VARARGS, NULL},
	 { (char *)"iCelRegion_CreateMapFile", _wrap_iCelRegion_CreateMapFile, METH_VARARGS, NULL},
	 { (char *)"iCelRegion_GetMapFileCount", _wrap_iCelRegion_GetMapFileCount, METH_VARARGS, NULL},
	 { (char *)"iCelRegion_GetMapFile", _wrap_iCelRegion_GetMapFile, METH_VARARGS, NULL},
	 { (char *)"iCelRegion_RemoveMapFile", _wrap_iCelRegion_RemoveMapFile, METH_VARARGS, NULL},
	 { (char *)"iCelRegion_RemoveAllMapFiles", _wrap_iCelRegion_RemoveAllMapFiles, METH_VARARGS, NULL},
	 { (char *)"iCelRegion_AssociateEntity", _wrap_iCelRegion_AssociateEntity, METH_VARARGS, NULL},
	 { (char *)"iCelRegion_DissociateEntity", _wrap_iCelRegion_DissociateEntity, METH_VARARGS, NULL},
	 { (char *)"delete_iCelRegion", _wrap_delete_iCelRegion, METH_VARARGS, NULL},
	 { (char *)"iCelRegion_swigregister", iCelRegion_swigregister, METH_VARARGS, NULL},
	 { (char *)"iCelZone_GetName", _wrap_iCelZone_GetName, METH_VARARGS, NULL},
	 { (char *)"iCelZone_LinkRegion", _wrap_iCelZone_LinkRegion, METH_VARARGS, NULL},
	 { (char *)"iCelZone_GetRegionCount", _wrap_iCelZone_GetRegionCount, METH_VARARGS, NULL},
	 { (char *)"iCelZone_GetRegion", _wrap_iCelZone_GetRegion, METH_VARARGS, NULL},
	 { (char *)"iCelZone_FindRegion", _wrap_iCelZone_FindRegion, METH_VARARGS, NULL},
	 { (char *)"iCelZone_UnlinkRegion", _wrap_iCelZone_UnlinkRegion, METH_VARARGS, NULL},
	 { (char *)"iCelZone_UnlinkAllRegions", _wrap_iCelZone_UnlinkAllRegions, METH_VARARGS, NULL},
	 { (char *)"delete_iCelZone", _wrap_delete_iCelZone, METH_VARARGS, NULL},
	 { (char *)"iCelZone_swigregister", iCelZone_swigregister, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_EnableColliderWrappers", _wrap_iPcZoneManager_EnableColliderWrappers, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_IsColliderWrappers", _wrap_iPcZoneManager_IsColliderWrappers, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_SetLoadingMode", _wrap_iPcZoneManager_SetLoadingMode, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_GetLoadingMode", _wrap_iPcZoneManager_GetLoadingMode, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_Load", _wrap_iPcZoneManager_Load, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_CreateZone", _wrap_iPcZoneManager_CreateZone, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_GetZoneCount", _wrap_iPcZoneManager_GetZoneCount, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_GetZone", _wrap_iPcZoneManager_GetZone, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_FindZone", _wrap_iPcZoneManager_FindZone, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_RemoveZone", _wrap_iPcZoneManager_RemoveZone, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_RemoveAllZones", _wrap_iPcZoneManager_RemoveAllZones, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_CreateRegion", _wrap_iPcZoneManager_CreateRegion, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_GetRegionCount", _wrap_iPcZoneManager_GetRegionCount, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_GetRegion", _wrap_iPcZoneManager_GetRegion, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_FindRegion", _wrap_iPcZoneManager_FindRegion, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_RemoveRegion", _wrap_iPcZoneManager_RemoveRegion, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_RemoveAllRegions", _wrap_iPcZoneManager_RemoveAllRegions, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_FindStartLocations", _wrap_iPcZoneManager_FindStartLocations, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_GetLastStartLocation", _wrap_iPcZoneManager_GetLastStartLocation, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_GetLastStartRegionName", _wrap_iPcZoneManager_GetLastStartRegionName, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_GetLastStartName", _wrap_iPcZoneManager_GetLastStartName, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_PointCamera", _wrap_iPcZoneManager_PointCamera, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_PointMesh", _wrap_iPcZoneManager_PointMesh, METH_VARARGS, NULL},
	 { (char *)"delete_iPcZoneManager", _wrap_delete_iPcZoneManager, METH_VARARGS, NULL},
	 { (char *)"iPcZoneManager_swigregister", iPcZoneManager_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateZoneManager", _wrap_celCreateZoneManager, METH_VARARGS, NULL},
	 { (char *)"celGetZoneManager", _wrap_celGetZoneManager, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcZoneManager", _wrap_scfQuery_iPcZoneManager, METH_VARARGS, NULL},
	 { (char *)"iPcCommandInput_Activate", _wrap_iPcCommandInput_Activate, METH_VARARGS, NULL},
	 { (char *)"iPcCommandInput_ScreenCoordinates", _wrap_iPcCommandInput_ScreenCoordinates, METH_VARARGS, NULL},
	 { (char *)"iPcCommandInput_ScreenToCentered", _wrap_iPcCommandInput_ScreenToCentered, METH_VARARGS, NULL},
	 { (char *)"iPcCommandInput_CenteredToScreen", _wrap_iPcCommandInput_CenteredToScreen, METH_VARARGS, NULL},
	 { (char *)"iPcCommandInput_LoadConfig", _wrap_iPcCommandInput_LoadConfig, METH_VARARGS, NULL},
	 { (char *)"iPcCommandInput_Bind", _wrap_iPcCommandInput_Bind, METH_VARARGS, NULL},
	 { (char *)"iPcCommandInput_GetBind", _wrap_iPcCommandInput_GetBind, METH_VARARGS, NULL},
	 { (char *)"iPcCommandInput_RemoveBind", _wrap_iPcCommandInput_RemoveBind, METH_VARARGS, NULL},
	 { (char *)"iPcCommandInput_RemoveAllBinds", _wrap_iPcCommandInput_RemoveAllBinds, METH_VARARGS, NULL},
	 { (char *)"delete_iPcCommandInput", _wrap_delete_iPcCommandInput, METH_VARARGS, NULL},
	 { (char *)"iPcCommandInput_swigregister", iPcCommandInput_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateCommandInput", _wrap_celCreateCommandInput, METH_VARARGS, NULL},
	 { (char *)"celGetCommandInput", _wrap_celGetCommandInput, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcCommandInput", _wrap_scfQuery_iPcCommandInput, METH_VARARGS, NULL},
	 { (char *)"iPcGravityCallback_Callback", _wrap_iPcGravityCallback_Callback, METH_VARARGS, NULL},
	 { (char *)"delete_iPcGravityCallback", _wrap_delete_iPcGravityCallback, METH_VARARGS, NULL},
	 { (char *)"iPcGravityCallback_swigregister", iPcGravityCallback_swigregister, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_SetAnchor", _wrap_iPcLinearMovement_SetAnchor, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_GetAnchor", _wrap_iPcLinearMovement_GetAnchor, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_SetAngularVelocity", _wrap_iPcLinearMovement_SetAngularVelocity, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_SetSpeed", _wrap_iPcLinearMovement_SetSpeed, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_SetVelocity", _wrap_iPcLinearMovement_SetVelocity, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_AddVelocity", _wrap_iPcLinearMovement_AddVelocity, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_ClearWorldVelocity", _wrap_iPcLinearMovement_ClearWorldVelocity, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_GetVelocity", _wrap_iPcLinearMovement_GetVelocity, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_GetAngularVelocity", _wrap_iPcLinearMovement_GetAngularVelocity, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_GetCDDimensions", _wrap_iPcLinearMovement_GetCDDimensions, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_InitCD", _wrap_iPcLinearMovement_InitCD, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_TimeDiff", _wrap_iPcLinearMovement_TimeDiff, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_GetDRData", _wrap_iPcLinearMovement_GetDRData, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_SetDRData", _wrap_iPcLinearMovement_SetDRData, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_SetSoftDRData", _wrap_iPcLinearMovement_SetSoftDRData, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_GetLastPosition", _wrap_iPcLinearMovement_GetLastPosition, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_GetLastFullPosition", _wrap_iPcLinearMovement_GetLastFullPosition, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_IsPath", _wrap_iPcLinearMovement_IsPath, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_GetSector", _wrap_iPcLinearMovement_GetSector, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_ExtrapolatePosition", _wrap_iPcLinearMovement_ExtrapolatePosition, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_UpdateDRDelta", _wrap_iPcLinearMovement_UpdateDRDelta, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_UpdateDR", _wrap_iPcLinearMovement_UpdateDR, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_SetPath", _wrap_iPcLinearMovement_SetPath, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_SetPathTime", _wrap_iPcLinearMovement_SetPathTime, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_SetPathSpeed", _wrap_iPcLinearMovement_SetPathSpeed, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_SetPathAction", _wrap_iPcLinearMovement_SetPathAction, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_SetPathSector", _wrap_iPcLinearMovement_SetPathSector, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_IsOnGround", _wrap_iPcLinearMovement_IsOnGround, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_SetOnGround", _wrap_iPcLinearMovement_SetOnGround, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_SetHugGround", _wrap_iPcLinearMovement_SetHugGround, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_SetDeltaLimit", _wrap_iPcLinearMovement_SetDeltaLimit, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_RotateV", _wrap_iPcLinearMovement_RotateV, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_SetGravity", _wrap_iPcLinearMovement_SetGravity, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_GetGravity", _wrap_iPcLinearMovement_GetGravity, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_ResetGravity", _wrap_iPcLinearMovement_ResetGravity, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_AddGravityCallback", _wrap_iPcLinearMovement_AddGravityCallback, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_RemoveGravityCallback", _wrap_iPcLinearMovement_RemoveGravityCallback, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_GetPortalDisplacement", _wrap_iPcLinearMovement_GetPortalDisplacement, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_ClearPortalDisplacement", _wrap_iPcLinearMovement_ClearPortalDisplacement, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_SetFullPosition", _wrap_iPcLinearMovement_SetFullPosition, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_SetPosition", _wrap_iPcLinearMovement_SetPosition, METH_VARARGS, NULL},
	 { (char *)"delete_iPcLinearMovement", _wrap_delete_iPcLinearMovement, METH_VARARGS, NULL},
	 { (char *)"iPcLinearMovement_swigregister", iPcLinearMovement_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateLinearMovement", _wrap_celCreateLinearMovement, METH_VARARGS, NULL},
	 { (char *)"celGetLinearMovement", _wrap_celGetLinearMovement, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcLinearMovement", _wrap_scfQuery_iPcLinearMovement, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_Forward", _wrap_iPcActorMove_Forward, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_IsMovingForward", _wrap_iPcActorMove_IsMovingForward, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_Backward", _wrap_iPcActorMove_Backward, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_IsMovingBackward", _wrap_iPcActorMove_IsMovingBackward, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_StrafeLeft", _wrap_iPcActorMove_StrafeLeft, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_IsStrafingLeft", _wrap_iPcActorMove_IsStrafingLeft, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_StrafeRight", _wrap_iPcActorMove_StrafeRight, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_IsStrafingRight", _wrap_iPcActorMove_IsStrafingRight, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_RotateLeft", _wrap_iPcActorMove_RotateLeft, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_IsRotatingLeft", _wrap_iPcActorMove_IsRotatingLeft, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_RotateRight", _wrap_iPcActorMove_RotateRight, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_IsRotatingRight", _wrap_iPcActorMove_IsRotatingRight, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_RotateTo", _wrap_iPcActorMove_RotateTo, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_Run", _wrap_iPcActorMove_Run, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_IsRunning", _wrap_iPcActorMove_IsRunning, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_AutoRun", _wrap_iPcActorMove_AutoRun, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_IsAutoRunning", _wrap_iPcActorMove_IsAutoRunning, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_Jump", _wrap_iPcActorMove_Jump, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_ToggleCameraMode", _wrap_iPcActorMove_ToggleCameraMode, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_SetMovementSpeed", _wrap_iPcActorMove_SetMovementSpeed, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_GetMovementSpeed", _wrap_iPcActorMove_GetMovementSpeed, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_SetRunningSpeed", _wrap_iPcActorMove_SetRunningSpeed, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_GetRunningSpeed", _wrap_iPcActorMove_GetRunningSpeed, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_SetRotationSpeed", _wrap_iPcActorMove_SetRotationSpeed, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_GetRotationSpeed", _wrap_iPcActorMove_GetRotationSpeed, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_SetJumpingVelocity", _wrap_iPcActorMove_SetJumpingVelocity, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_GetJumpingVelocity", _wrap_iPcActorMove_GetJumpingVelocity, METH_VARARGS, NULL},
	 { (char *)"delete_iPcActorMove", _wrap_delete_iPcActorMove, METH_VARARGS, NULL},
	 { (char *)"iPcActorMove_swigregister", iPcActorMove_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateActorMove", _wrap_celCreateActorMove, METH_VARARGS, NULL},
	 { (char *)"celGetActorMove", _wrap_celGetActorMove, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcActorMove", _wrap_scfQuery_iPcActorMove, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_SetRegion", _wrap_iPcCamera_SetRegion, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_SetZoneManager", _wrap_iPcCamera_SetZoneManager, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_SetRectangle", _wrap_iPcCamera_SetRectangle, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_GetCamera", _wrap_iPcCamera_GetCamera, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_GetView", _wrap_iPcCamera_GetView, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_SetClearZBuffer", _wrap_iPcCamera_SetClearZBuffer, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_GetClearZBuffer", _wrap_iPcCamera_GetClearZBuffer, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_SetClearScreen", _wrap_iPcCamera_SetClearScreen, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_GetClearScreen", _wrap_iPcCamera_GetClearScreen, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_DisableDistanceClipping", _wrap_iPcCamera_DisableDistanceClipping, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_EnableFixedDistanceClipping", _wrap_iPcCamera_EnableFixedDistanceClipping, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_EnableAdaptiveDistanceClipping", _wrap_iPcCamera_EnableAdaptiveDistanceClipping, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_UseDistanceClipping", _wrap_iPcCamera_UseDistanceClipping, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_UseFixedDistanceClipping", _wrap_iPcCamera_UseFixedDistanceClipping, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_GetFixedDistance", _wrap_iPcCamera_GetFixedDistance, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_GetAdaptiveMinFPS", _wrap_iPcCamera_GetAdaptiveMinFPS, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_GetAdaptiveMaxFPS", _wrap_iPcCamera_GetAdaptiveMaxFPS, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_GetAdaptiveMinDistance", _wrap_iPcCamera_GetAdaptiveMinDistance, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_SetAutoDraw", _wrap_iPcCamera_SetAutoDraw, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_Draw", _wrap_iPcCamera_Draw, METH_VARARGS, NULL},
	 { (char *)"delete_iPcCamera", _wrap_delete_iPcCamera, METH_VARARGS, NULL},
	 { (char *)"iPcCamera_swigregister", iPcCamera_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateCamera", _wrap_celCreateCamera, METH_VARARGS, NULL},
	 { (char *)"celGetCamera", _wrap_celGetCamera, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcCamera", _wrap_scfQuery_iPcCamera, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_SetFollowEntity", _wrap_iPcDefaultCamera_SetFollowEntity, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_SetMode", _wrap_iPcDefaultCamera_SetMode, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_GetMode", _wrap_iPcDefaultCamera_GetMode, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_SetModeName", _wrap_iPcDefaultCamera_SetModeName, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_GetModeName", _wrap_iPcDefaultCamera_GetModeName, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_GetNextMode", _wrap_iPcDefaultCamera_GetNextMode, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_SetSpringParameters", _wrap_iPcDefaultCamera_SetSpringParameters, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_SetMinMaxCameraDistance", _wrap_iPcDefaultCamera_SetMinMaxCameraDistance, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_SetTurnSpeed", _wrap_iPcDefaultCamera_SetTurnSpeed, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_SetSwingCoef", _wrap_iPcDefaultCamera_SetSwingCoef, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_SetFirstPersonOffset", _wrap_iPcDefaultCamera_SetFirstPersonOffset, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_SetThirdPersonOffset", _wrap_iPcDefaultCamera_SetThirdPersonOffset, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_CenterCamera", _wrap_iPcDefaultCamera_CenterCamera, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_SetPitch", _wrap_iPcDefaultCamera_SetPitch, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_GetPitch", _wrap_iPcDefaultCamera_GetPitch, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_SetPitchVelocity", _wrap_iPcDefaultCamera_SetPitchVelocity, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_GetPitchVelocity", _wrap_iPcDefaultCamera_GetPitchVelocity, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_MovePitch", _wrap_iPcDefaultCamera_MovePitch, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_SetYaw", _wrap_iPcDefaultCamera_SetYaw, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_MoveYaw", _wrap_iPcDefaultCamera_MoveYaw, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_GetYaw", _wrap_iPcDefaultCamera_GetYaw, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_SetYawVelocity", _wrap_iPcDefaultCamera_SetYawVelocity, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_GetYawVelocity", _wrap_iPcDefaultCamera_GetYawVelocity, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_SetDistance", _wrap_iPcDefaultCamera_SetDistance, METH_VARARGS, NULL},
	 { (char *)"delete_iPcDefaultCamera", _wrap_delete_iPcDefaultCamera, METH_VARARGS, NULL},
	 { (char *)"iPcDefaultCamera_swigregister", iPcDefaultCamera_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateDefaultCamera", _wrap_celCreateDefaultCamera, METH_VARARGS, NULL},
	 { (char *)"celGetDefaultCamera", _wrap_celGetDefaultCamera, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcDefaultCamera", _wrap_scfQuery_iPcDefaultCamera, METH_VARARGS, NULL},
	 { (char *)"iPcSimpleCamera_SetDrawMesh", _wrap_iPcSimpleCamera_SetDrawMesh, METH_VARARGS, NULL},
	 { (char *)"iPcSimpleCamera_SetCameraOffset", _wrap_iPcSimpleCamera_SetCameraOffset, METH_VARARGS, NULL},
	 { (char *)"iPcSimpleCamera_SetLookAtOffset", _wrap_iPcSimpleCamera_SetLookAtOffset, METH_VARARGS, NULL},
	 { (char *)"iPcSimpleCamera_SetMesh", _wrap_iPcSimpleCamera_SetMesh, METH_VARARGS, NULL},
	 { (char *)"iPcSimpleCamera_Draw", _wrap_iPcSimpleCamera_Draw, METH_VARARGS, NULL},
	 { (char *)"delete_iPcSimpleCamera", _wrap_delete_iPcSimpleCamera, METH_VARARGS, NULL},
	 { (char *)"iPcSimpleCamera_swigregister", iPcSimpleCamera_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateSimpleCamera", _wrap_celCreateSimpleCamera, METH_VARARGS, NULL},
	 { (char *)"celGetSimpleCamera", _wrap_celGetSimpleCamera, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcSimpleCamera", _wrap_scfQuery_iPcSimpleCamera, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelectListener_MouseDown", _wrap_iPcMeshSelectListener_MouseDown, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelectListener_MouseUp", _wrap_iPcMeshSelectListener_MouseUp, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelectListener_MouseMove", _wrap_iPcMeshSelectListener_MouseMove, METH_VARARGS, NULL},
	 { (char *)"delete_iPcMeshSelectListener", _wrap_delete_iPcMeshSelectListener, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelectListener_swigregister", iPcMeshSelectListener_swigregister, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_AddMeshSelectListener", _wrap_iPcMeshSelect_AddMeshSelectListener, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_RemoveMeshSelectListener", _wrap_iPcMeshSelect_RemoveMeshSelectListener, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_SetCamera", _wrap_iPcMeshSelect_SetCamera, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_SetMouseButtons", _wrap_iPcMeshSelect_SetMouseButtons, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_GetMouseButtons", _wrap_iPcMeshSelect_GetMouseButtons, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_SetGlobalSelection", _wrap_iPcMeshSelect_SetGlobalSelection, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_HasGlobalSelection", _wrap_iPcMeshSelect_HasGlobalSelection, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_SetFollowMode", _wrap_iPcMeshSelect_SetFollowMode, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_HasFollowMode", _wrap_iPcMeshSelect_HasFollowMode, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_SetFollowAlwaysMode", _wrap_iPcMeshSelect_SetFollowAlwaysMode, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_HasFollowAlwaysMode", _wrap_iPcMeshSelect_HasFollowAlwaysMode, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_SetDragMode", _wrap_iPcMeshSelect_SetDragMode, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_HasDragMode", _wrap_iPcMeshSelect_HasDragMode, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_SetDragPlaneNormal", _wrap_iPcMeshSelect_SetDragPlaneNormal, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_GetDragPlaneNormal", _wrap_iPcMeshSelect_GetDragPlaneNormal, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_SetSendmoveEvent", _wrap_iPcMeshSelect_SetSendmoveEvent, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_HasSendmoveEvent", _wrap_iPcMeshSelect_HasSendmoveEvent, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_SetSendupEvent", _wrap_iPcMeshSelect_SetSendupEvent, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_HasSendupEvent", _wrap_iPcMeshSelect_HasSendupEvent, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_SetSenddownEvent", _wrap_iPcMeshSelect_SetSenddownEvent, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_HasSenddownEvent", _wrap_iPcMeshSelect_HasSenddownEvent, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_SetMaxSelectionDistance", _wrap_iPcMeshSelect_SetMaxSelectionDistance, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_GetMaxSelectionDistance", _wrap_iPcMeshSelect_GetMaxSelectionDistance, METH_VARARGS, NULL},
	 { (char *)"delete_iPcMeshSelect", _wrap_delete_iPcMeshSelect, METH_VARARGS, NULL},
	 { (char *)"iPcMeshSelect_swigregister", iPcMeshSelect_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateMeshSelect", _wrap_celCreateMeshSelect, METH_VARARGS, NULL},
	 { (char *)"celGetMeshSelect", _wrap_celGetMeshSelect, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcMeshSelect", _wrap_scfQuery_iPcMeshSelect, METH_VARARGS, NULL},
	 { (char *)"iPcMesh_SetPath", _wrap_iPcMesh_SetPath, METH_VARARGS, NULL},
	 { (char *)"iPcMesh_LoadMesh", _wrap_iPcMesh_LoadMesh, METH_VARARGS, NULL},
	 { (char *)"iPcMesh_CreateEmptyThing", _wrap_iPcMesh_CreateEmptyThing, METH_VARARGS, NULL},
	 { (char *)"iPcMesh_GetMesh", _wrap_iPcMesh_GetMesh, METH_VARARGS, NULL},
	 { (char *)"iPcMesh_MoveMesh", _wrap_iPcMesh_MoveMesh, METH_VARARGS, NULL},
	 { (char *)"iPcMesh_SetAction", _wrap_iPcMesh_SetAction, METH_VARARGS, NULL},
	 { (char *)"iPcMesh_GetAction", _wrap_iPcMesh_GetAction, METH_VARARGS, NULL},
	 { (char *)"iPcMesh_SetReverseAction", _wrap_iPcMesh_SetReverseAction, METH_VARARGS, NULL},
	 { (char *)"iPcMesh_Hide", _wrap_iPcMesh_Hide, METH_VARARGS, NULL},
	 { (char *)"iPcMesh_Show", _wrap_iPcMesh_Show, METH_VARARGS, NULL},
	 { (char *)"iPcMesh_IsVisible", _wrap_iPcMesh_IsVisible, METH_VARARGS, NULL},
	 { (char *)"delete_iPcMesh", _wrap_delete_iPcMesh, METH_VARARGS, NULL},
	 { (char *)"iPcMesh_swigregister", iPcMesh_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateMesh", _wrap_celCreateMesh, METH_VARARGS, NULL},
	 { (char *)"celGetMesh", _wrap_celGetMesh, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcMesh", _wrap_scfQuery_iPcMesh, METH_VARARGS, NULL},
	 { (char *)"iPcTimer_WakeUp", _wrap_iPcTimer_WakeUp, METH_VARARGS, NULL},
	 { (char *)"iPcTimer_WakeUpFrame", _wrap_iPcTimer_WakeUpFrame, METH_VARARGS, NULL},
	 { (char *)"iPcTimer_Clear", _wrap_iPcTimer_Clear, METH_VARARGS, NULL},
	 { (char *)"delete_iPcTimer", _wrap_delete_iPcTimer, METH_VARARGS, NULL},
	 { (char *)"iPcTimer_swigregister", iPcTimer_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateTimer", _wrap_celCreateTimer, METH_VARARGS, NULL},
	 { (char *)"celGetTimer", _wrap_celGetTimer, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcTimer", _wrap_scfQuery_iPcTimer, METH_VARARGS, NULL},
	 { (char *)"iPcSolid_SetMesh", _wrap_iPcSolid_SetMesh, METH_VARARGS, NULL},
	 { (char *)"iPcSolid_GetMesh", _wrap_iPcSolid_GetMesh, METH_VARARGS, NULL},
	 { (char *)"iPcSolid_GetCollider", _wrap_iPcSolid_GetCollider, METH_VARARGS, NULL},
	 { (char *)"delete_iPcSolid", _wrap_delete_iPcSolid, METH_VARARGS, NULL},
	 { (char *)"iPcSolid_swigregister", iPcSolid_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateSolid", _wrap_celCreateSolid, METH_VARARGS, NULL},
	 { (char *)"celGetSolid", _wrap_celGetSolid, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcSolid", _wrap_scfQuery_iPcSolid, METH_VARARGS, NULL},
	 { (char *)"iPcGravity_CreateGravityColliderFromMesh", _wrap_iPcGravity_CreateGravityColliderFromMesh, METH_VARARGS, NULL},
	 { (char *)"iPcGravity_GetGravityCollider", _wrap_iPcGravity_GetGravityCollider, METH_VARARGS, NULL},
	 { (char *)"iPcGravity_SetMovable", _wrap_iPcGravity_SetMovable, METH_VARARGS, NULL},
	 { (char *)"iPcGravity_GetMovable", _wrap_iPcGravity_GetMovable, METH_VARARGS, NULL},
	 { (char *)"iPcGravity_SetSolid", _wrap_iPcGravity_SetSolid, METH_VARARGS, NULL},
	 { (char *)"iPcGravity_GetSolid", _wrap_iPcGravity_GetSolid, METH_VARARGS, NULL},
	 { (char *)"iPcGravity_SetWeight", _wrap_iPcGravity_SetWeight, METH_VARARGS, NULL},
	 { (char *)"iPcGravity_GetWeight", _wrap_iPcGravity_GetWeight, METH_VARARGS, NULL},
	 { (char *)"iPcGravity_ClearForces", _wrap_iPcGravity_ClearForces, METH_VARARGS, NULL},
	 { (char *)"iPcGravity_ClearPermanentForces", _wrap_iPcGravity_ClearPermanentForces, METH_VARARGS, NULL},
	 { (char *)"iPcGravity_ResetSpeed", _wrap_iPcGravity_ResetSpeed, METH_VARARGS, NULL},
	 { (char *)"iPcGravity_ApplyForce", _wrap_iPcGravity_ApplyForce, METH_VARARGS, NULL},
	 { (char *)"iPcGravity_ApplyPermanentForce", _wrap_iPcGravity_ApplyPermanentForce, METH_VARARGS, NULL},
	 { (char *)"iPcGravity_IsResting", _wrap_iPcGravity_IsResting, METH_VARARGS, NULL},
	 { (char *)"iPcGravity_SetActive", _wrap_iPcGravity_SetActive, METH_VARARGS, NULL},
	 { (char *)"iPcGravity_IsActive", _wrap_iPcGravity_IsActive, METH_VARARGS, NULL},
	 { (char *)"delete_iPcGravity", _wrap_delete_iPcGravity, METH_VARARGS, NULL},
	 { (char *)"iPcGravity_swigregister", iPcGravity_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateGravity", _wrap_celCreateGravity, METH_VARARGS, NULL},
	 { (char *)"celGetGravity", _wrap_celGetGravity, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcGravity", _wrap_scfQuery_iPcGravity, METH_VARARGS, NULL},
	 { (char *)"iPcMovable_SetMesh", _wrap_iPcMovable_SetMesh, METH_VARARGS, NULL},
	 { (char *)"iPcMovable_GetMesh", _wrap_iPcMovable_GetMesh, METH_VARARGS, NULL},
	 { (char *)"iPcMovable_SetPos", _wrap_iPcMovable_SetPos, METH_VARARGS, NULL},
	 { (char *)"iPcMovable_AddConstraint", _wrap_iPcMovable_AddConstraint, METH_VARARGS, NULL},
	 { (char *)"iPcMovable_RemoveConstraint", _wrap_iPcMovable_RemoveConstraint, METH_VARARGS, NULL},
	 { (char *)"iPcMovable_RemoveAllConstraints", _wrap_iPcMovable_RemoveAllConstraints, METH_VARARGS, NULL},
	 { (char *)"delete_iPcMovable", _wrap_delete_iPcMovable, METH_VARARGS, NULL},
	 { (char *)"iPcMovable_swigregister", iPcMovable_swigregister, METH_VARARGS, NULL},
	 { (char *)"iPcMovableConstraint_CheckMove", _wrap_iPcMovableConstraint_CheckMove, METH_VARARGS, NULL},
	 { (char *)"delete_iPcMovableConstraint", _wrap_delete_iPcMovableConstraint, METH_VARARGS, NULL},
	 { (char *)"iPcMovableConstraint_swigregister", iPcMovableConstraint_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateMovable", _wrap_celCreateMovable, METH_VARARGS, NULL},
	 { (char *)"celGetMovable", _wrap_celGetMovable, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcMovable", _wrap_scfQuery_iPcMovable, METH_VARARGS, NULL},
	 { (char *)"iPcInventoryListener_AddChild", _wrap_iPcInventoryListener_AddChild, METH_VARARGS, NULL},
	 { (char *)"iPcInventoryListener_RemoveChild", _wrap_iPcInventoryListener_RemoveChild, METH_VARARGS, NULL},
	 { (char *)"delete_iPcInventoryListener", _wrap_delete_iPcInventoryListener, METH_VARARGS, NULL},
	 { (char *)"iPcInventoryListener_swigregister", iPcInventoryListener_swigregister, METH_VARARGS, NULL},
	 { (char *)"iCelInventorySpaceSlot_GetEntity", _wrap_iCelInventorySpaceSlot_GetEntity, METH_VARARGS, NULL},
	 { (char *)"iCelInventorySpaceSlot_AddEntity", _wrap_iCelInventorySpaceSlot_AddEntity, METH_VARARGS, NULL},
	 { (char *)"iCelInventorySpaceSlot_RemoveEntity", _wrap_iCelInventorySpaceSlot_RemoveEntity, METH_VARARGS, NULL},
	 { (char *)"iCelInventorySpaceSlot_GetCount", _wrap_iCelInventorySpaceSlot_GetCount, METH_VARARGS, NULL},
	 { (char *)"iCelInventorySpaceSlot_RemoveAll", _wrap_iCelInventorySpaceSlot_RemoveAll, METH_VARARGS, NULL},
	 { (char *)"iCelInventorySpaceSlot_IsEmpty", _wrap_iCelInventorySpaceSlot_IsEmpty, METH_VARARGS, NULL},
	 { (char *)"delete_iCelInventorySpaceSlot", _wrap_delete_iCelInventorySpaceSlot, METH_VARARGS, NULL},
	 { (char *)"iCelInventorySpaceSlot_swigregister", iCelInventorySpaceSlot_swigregister, METH_VARARGS, NULL},
	 { (char *)"iCelInventorySpace_GetSpaceTotal", _wrap_iCelInventorySpace_GetSpaceTotal, METH_VARARGS, NULL},
	 { (char *)"iCelInventorySpace_GetSpaceLeft", _wrap_iCelInventorySpace_GetSpaceLeft, METH_VARARGS, NULL},
	 { (char *)"iCelInventorySpace_GetSpaceTaken", _wrap_iCelInventorySpace_GetSpaceTaken, METH_VARARGS, NULL},
	 { (char *)"iCelInventorySpace_AddEntity", _wrap_iCelInventorySpace_AddEntity, METH_VARARGS, NULL},
	 { (char *)"iCelInventorySpace_RemoveEntity", _wrap_iCelInventorySpace_RemoveEntity, METH_VARARGS, NULL},
	 { (char *)"iCelInventorySpace_RemoveAll", _wrap_iCelInventorySpace_RemoveAll, METH_VARARGS, NULL},
	 { (char *)"iCelInventorySpace_GetSlot", _wrap_iCelInventorySpace_GetSlot, METH_VARARGS, NULL},
	 { (char *)"iCelInventorySpace_GetEntity", _wrap_iCelInventorySpace_GetEntity, METH_VARARGS, NULL},
	 { (char *)"delete_iCelInventorySpace", _wrap_delete_iCelInventorySpace, METH_VARARGS, NULL},
	 { (char *)"iCelInventorySpace_swigregister", iCelInventorySpace_swigregister, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_AddInventoryListener", _wrap_iPcInventory_AddInventoryListener, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_RemoveInventoryListener", _wrap_iPcInventory_RemoveInventoryListener, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_AddEntity", _wrap_iPcInventory_AddEntity, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_RemoveEntity", _wrap_iPcInventory_RemoveEntity, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_RemoveAll", _wrap_iPcInventory_RemoveAll, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_GetEntityCount", _wrap_iPcInventory_GetEntityCount, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_GetEntity", _wrap_iPcInventory_GetEntity, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_GetEntitySlot", _wrap_iPcInventory_GetEntitySlot, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_SetStrictCharacteristics", _wrap_iPcInventory_SetStrictCharacteristics, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_HasStrictCharacteristics", _wrap_iPcInventory_HasStrictCharacteristics, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_SetConstraints", _wrap_iPcInventory_SetConstraints, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_GetConstraints", _wrap_iPcInventory_GetConstraints, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_RemoveConstraints", _wrap_iPcInventory_RemoveConstraints, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_RemoveAllConstraints", _wrap_iPcInventory_RemoveAllConstraints, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_GetCurrentCharacteristic", _wrap_iPcInventory_GetCurrentCharacteristic, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_MarkDirty", _wrap_iPcInventory_MarkDirty, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_TestConstraints", _wrap_iPcInventory_TestConstraints, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_Dump", _wrap_iPcInventory_Dump, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_SetSpace", _wrap_iPcInventory_SetSpace, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_GetSpace", _wrap_iPcInventory_GetSpace, METH_VARARGS, NULL},
	 { (char *)"delete_iPcInventory", _wrap_delete_iPcInventory, METH_VARARGS, NULL},
	 { (char *)"iPcInventory_swigregister", iPcInventory_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateInventory", _wrap_celCreateInventory, METH_VARARGS, NULL},
	 { (char *)"celGetInventory", _wrap_celGetInventory, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcInventory", _wrap_scfQuery_iPcInventory, METH_VARARGS, NULL},
	 { (char *)"iPcCharacteristics_SetCharacteristic", _wrap_iPcCharacteristics_SetCharacteristic, METH_VARARGS, NULL},
	 { (char *)"iPcCharacteristics_SetInheritedCharacteristic", _wrap_iPcCharacteristics_SetInheritedCharacteristic, METH_VARARGS, NULL},
	 { (char *)"iPcCharacteristics_GetCharacteristic", _wrap_iPcCharacteristics_GetCharacteristic, METH_VARARGS, NULL},
	 { (char *)"iPcCharacteristics_GetLocalCharacteristic", _wrap_iPcCharacteristics_GetLocalCharacteristic, METH_VARARGS, NULL},
	 { (char *)"iPcCharacteristics_GetInheritedCharacteristic", _wrap_iPcCharacteristics_GetInheritedCharacteristic, METH_VARARGS, NULL},
	 { (char *)"iPcCharacteristics_ClearCharacteristic", _wrap_iPcCharacteristics_ClearCharacteristic, METH_VARARGS, NULL},
	 { (char *)"iPcCharacteristics_HasCharacteristic", _wrap_iPcCharacteristics_HasCharacteristic, METH_VARARGS, NULL},
	 { (char *)"iPcCharacteristics_ClearAll", _wrap_iPcCharacteristics_ClearAll, METH_VARARGS, NULL},
	 { (char *)"iPcCharacteristics_AddToInventory", _wrap_iPcCharacteristics_AddToInventory, METH_VARARGS, NULL},
	 { (char *)"iPcCharacteristics_RemoveFromInventory", _wrap_iPcCharacteristics_RemoveFromInventory, METH_VARARGS, NULL},
	 { (char *)"iPcCharacteristics_MarkDirty", _wrap_iPcCharacteristics_MarkDirty, METH_VARARGS, NULL},
	 { (char *)"iPcCharacteristics_TestConstraints", _wrap_iPcCharacteristics_TestConstraints, METH_VARARGS, NULL},
	 { (char *)"iPcCharacteristics_Dump", _wrap_iPcCharacteristics_Dump, METH_VARARGS, NULL},
	 { (char *)"delete_iPcCharacteristics", _wrap_delete_iPcCharacteristics, METH_VARARGS, NULL},
	 { (char *)"iPcCharacteristics_swigregister", iPcCharacteristics_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateCharacteristics", _wrap_celCreateCharacteristics, METH_VARARGS, NULL},
	 { (char *)"celGetCharacteristics", _wrap_celGetCharacteristics, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcCharacteristics", _wrap_scfQuery_iPcCharacteristics, METH_VARARGS, NULL},
	 { (char *)"iPcTooltip_SetText", _wrap_iPcTooltip_SetText, METH_VARARGS, NULL},
	 { (char *)"iPcTooltip_Show", _wrap_iPcTooltip_Show, METH_VARARGS, NULL},
	 { (char *)"iPcTooltip_Hide", _wrap_iPcTooltip_Hide, METH_VARARGS, NULL},
	 { (char *)"iPcTooltip_IsVisible", _wrap_iPcTooltip_IsVisible, METH_VARARGS, NULL},
	 { (char *)"iPcTooltip_SetTextColor", _wrap_iPcTooltip_SetTextColor, METH_VARARGS, NULL},
	 { (char *)"iPcTooltip_SetBackgroundColor", _wrap_iPcTooltip_SetBackgroundColor, METH_VARARGS, NULL},
	 { (char *)"iPcTooltip_SetFont", _wrap_iPcTooltip_SetFont, METH_VARARGS, NULL},
	 { (char *)"iPcTooltip_SetJustify", _wrap_iPcTooltip_SetJustify, METH_VARARGS, NULL},
	 { (char *)"delete_iPcTooltip", _wrap_delete_iPcTooltip, METH_VARARGS, NULL},
	 { (char *)"iPcTooltip_swigregister", iPcTooltip_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateToolTip", _wrap_celCreateToolTip, METH_VARARGS, NULL},
	 { (char *)"celGetToolTip", _wrap_celGetToolTip, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcTooltip", _wrap_scfQuery_iPcTooltip, METH_VARARGS, NULL},
	 { (char *)"iPcSoundListener_GetSoundListener", _wrap_iPcSoundListener_GetSoundListener, METH_VARARGS, NULL},
	 { (char *)"delete_iPcSoundListener", _wrap_delete_iPcSoundListener, METH_VARARGS, NULL},
	 { (char *)"iPcSoundListener_swigregister", iPcSoundListener_swigregister, METH_VARARGS, NULL},
	 { (char *)"iPcSoundSource_GetSoundSource", _wrap_iPcSoundSource_GetSoundSource, METH_VARARGS, NULL},
	 { (char *)"iPcSoundSource_SetSoundName", _wrap_iPcSoundSource_SetSoundName, METH_VARARGS, NULL},
	 { (char *)"iPcSoundSource_GetSoundName", _wrap_iPcSoundSource_GetSoundName, METH_VARARGS, NULL},
	 { (char *)"delete_iPcSoundSource", _wrap_delete_iPcSoundSource, METH_VARARGS, NULL},
	 { (char *)"iPcSoundSource_swigregister", iPcSoundSource_swigregister, METH_VARARGS, NULL},
	 { (char *)"celCreateSoundSource", _wrap_celCreateSoundSource, METH_VARARGS, NULL},
	 { (char *)"celGetSoundSource", _wrap_celGetSoundSource, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcSoundSource", _wrap_scfQuery_iPcSoundSource, METH_VARARGS, NULL},
	 { (char *)"celCreateSoundListener", _wrap_celCreateSoundListener, METH_VARARGS, NULL},
	 { (char *)"celGetSoundListener", _wrap_celGetSoundListener, METH_VARARGS, NULL},
	 { (char *)"scfQuery_iPcSoundListener", _wrap_scfQuery_iPcSoundListener, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_celInitializerTo_p_csInitializer(void *x) {
    return (void *)((csInitializer *)  ((celInitializer *) x));
}
static void *_p_csColor4To_p_csColor(void *x) {
    return (void *)((csColor *)  ((csColor4 *) x));
}
static void *_p_iSndSysSourceSoftware3DTo_p_iSndSysSource(void *x) {
    return (void *)((iSndSysSource *) (iSndSysSourceSoftware *) ((iSndSysSourceSoftware3D *) x));
}
static void *_p_iSndSysSourceSoftwareTo_p_iSndSysSource(void *x) {
    return (void *)((iSndSysSource *)  ((iSndSysSourceSoftware *) x));
}
static void *_p_iAwsRGBKeyTo_p_iBase(void *x) {
    return (void *)((iBase *) (iAwsKey *) ((iAwsRGBKey *) x));
}
static void *_p_iEventTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iEvent *) x));
}
static void *_p_iRendererLightmapTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iRendererLightmap *) x));
}
static void *_p_iSuperLightmapTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSuperLightmap *) x));
}
static void *_p_iConsoleOutputTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iConsoleOutput *) x));
}
static void *_p_iTerrainObjectStateTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iTerrainObjectState *) x));
}
static void *_p_iClipper2DTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iClipper2D *) x));
}
static void *_p_iDebugHelperTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iDebugHelper *) x));
}
static void *_p_iODEDynamicStateTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iODEDynamicState *) x));
}
static void *_p_iMaterialEngineTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iMaterialEngine *) x));
}
static void *_p_iDocumentAttributeTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iDocumentAttribute *) x));
}
static void *_p_iImageIOTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iImageIO *) x));
}
static void *_p_iODEHingeJointTo_p_iBase(void *x) {
    return (void *)((iBase *) (iODEGeneralJointState *) ((iODEHingeJoint *) x));
}
static void *_p_iPcMovableConstraintTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcMovableConstraint *) x));
}
static void *_p_iBillboardLayerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iBillboardLayer *) x));
}
static void *_p_iBillboardTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iBillboard *) x));
}
static void *_p_iPcBillboardTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcBillboard *) x));
}
static void *_p_iLoaderStatusTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iLoaderStatus *) x));
}
static void *_p_iImageTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iImage *) x));
}
static void *_p_iODEBallJointTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iODEBallJoint *) x));
}
static void *_p_iPcCharacteristicsTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcCharacteristics *) x));
}
static void *_p_iTextureHandleTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iTextureHandle *) x));
}
static void *_p_iGeneralMeshStateTo_p_iBase(void *x) {
    return (void *)((iBase *) (iGeneralMeshCommonState *) ((iGeneralMeshState *) x));
}
static void *_p_iDynamicsTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iDynamics *) x));
}
static void *_p_iParameterESMTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iParameterESM *) x));
}
static void *_p_iPcCommandInputTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcCommandInput *) x));
}
static void *_p_iAwsIntKeyTo_p_iBase(void *x) {
    return (void *)((iBase *) (iAwsKey *) ((iAwsIntKey *) x));
}
static void *_p_iSaverTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSaver *) x));
}
static void *_p_iODEDynamicSystemStateTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iODEDynamicSystemState *) x));
}
static void *_p_iMeshListTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iMeshList *) x));
}
static void *_p_iEventPlugTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iEventPlug *) x));
}
static void *_p_iCelPropertyClassTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCelPropertyClass *) x));
}
static void *_p_iODEJointStateTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iODEJointState *) x));
}
static void *_p_iODEGeneralJointStateTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iODEGeneralJointState *) x));
}
static void *_p_iSndSysWrapperTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSndSysWrapper *) x));
}
static void *_p_iSoundWrapperTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSoundWrapper *) x));
}
static void *_p_iTextureWrapperTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iTextureWrapper *) x));
}
static void *_p_iMaterialWrapperTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iMaterialWrapper *) x));
}
static void *_p_iMeshWrapperTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iMeshWrapper *) x));
}
static void *_p_iMeshFactoryWrapperTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iMeshFactoryWrapper *) x));
}
static void *_p_iStringTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iString *) x));
}
static void *_p_iSequenceWrapperTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSequenceWrapper *) x));
}
static void *_p_iEngineTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iEngine *) x));
}
static void *_p_iConsoleWatcherTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iConsoleWatcher *) x));
}
static void *_p_iPcMechanicsThrusterTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcMechanicsThruster *) x));
}
static void *_p_iPcInventoryTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcInventory *) x));
}
static void *_p_iMaterialTo_p_iBase(void *x) {
    return (void *)((iBase *) (iShaderVariableContext *) ((iMaterial *) x));
}
static void *_p_iSimpleFormerStateTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSimpleFormerState *) x));
}
static void *_p_iSprite2DUVAnimationTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSprite2DUVAnimation *) x));
}
static void *_p_iPolygonMeshTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPolygonMesh *) x));
}
static void *_p_iTerrainFactoryStateTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iTerrainFactoryState *) x));
}
static void *_p_iThingFactoryStateTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iThingFactoryState *) x));
}
static void *_p_iSpriteCal3DFactoryStateTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSpriteCal3DFactoryState *) x));
}
static void *_p_iSprite3DFactoryStateTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSprite3DFactoryState *) x));
}
static void *_p_iSprite2DFactoryStateTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSprite2DFactoryState *) x));
}
static void *_p_iGeneralFactoryStateTo_p_iBase(void *x) {
    return (void *)((iBase *) (iGeneralMeshCommonState *) ((iGeneralFactoryState *) x));
}
static void *_p_iSCFTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSCF *) x));
}
static void *_p_iDocumentTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iDocument *) x));
}
static void *_p_iGraphics2DTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iGraphics2D *) x));
}
static void *_p_iShaderPriorityListTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iShaderPriorityList *) x));
}
static void *_p_iCelEntityListTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCelEntityList *) x));
}
static void *_p_iSndSysSourceSoftware3DTo_p_iBase(void *x) {
    return (void *)((iBase *) (iSndSysSource *)(iSndSysSourceSoftware *) ((iSndSysSourceSoftware3D *) x));
}
static void *_p_iMeshObjectTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iMeshObject *) x));
}
static void *_p_iDataBufferTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iDataBuffer *) x));
}
static void *_p_iScriptObjectTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iScriptObject *) x));
}
static void *_p_iSequenceTimedOperationTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSequenceTimedOperation *) x));
}
static void *_p_iPcDefaultCameraTo_p_iBase(void *x) {
    return (void *)((iBase *) (iPcCamera *) ((iPcDefaultCamera *) x));
}
static void *_p_iFontServerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iFontServer *) x));
}
static void *_p_iStringArrayTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iStringArray *) x));
}
static void *_p_iReporterTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iReporter *) x));
}
static void *_p_iPathTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPath *) x));
}
static void *_p_iConfigIteratorTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iConfigIterator *) x));
}
static void *_p_iPluginIteratorTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPluginIterator *) x));
}
static void *_p_iEventAttributeIteratorTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iEventAttributeIterator *) x));
}
static void *_p_iObjectRegistryIteratorTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iObjectRegistryIterator *) x));
}
static void *_p_iObjectIteratorTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iObjectIterator *) x));
}
static void *_p_iLightIteratorTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iLightIterator *) x));
}
static void *_p_iSectorIteratorTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSectorIterator *) x));
}
static void *_p_iMeshWrapperIteratorTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iMeshWrapperIterator *) x));
}
static void *_p_iVisibilityObjectIteratorTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iVisibilityObjectIterator *) x));
}
static void *_p_iDocumentAttributeIteratorTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iDocumentAttributeIterator *) x));
}
static void *_p_iDocumentNodeIteratorTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iDocumentNodeIterator *) x));
}
static void *_p_iReporterIteratorTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iReporterIterator *) x));
}
static void *_p_iMapNodeTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iMapNode *) x));
}
static void *_p_iGenMeshAnimationControlTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iGenMeshAnimationControl *) x));
}
static void *_p_iEventNameRegistryTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iEventNameRegistry *) x));
}
static void *_p_iObjectRegistryTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iObjectRegistry *) x));
}
static void *_p_iCelPlLayerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCelPlLayer *) x));
}
static void *_p_iCelBlLayerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCelBlLayer *) x));
}
static void *_p_iPcLinearMovementTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcLinearMovement *) x));
}
static void *_p_iObjectNameChangeListenerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iObjectNameChangeListener *) x));
}
static void *_p_iSndSysListenerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSndSysListener *) x));
}
static void *_p_iSoundListenerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSoundListener *) x));
}
static void *_p_iObjectModelListenerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iObjectModelListener *) x));
}
static void *_p_iCameraSectorListenerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCameraSectorListener *) x));
}
static void *_p_iMovableListenerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iMovableListener *) x));
}
static void *_p_iVisibilityCullerListenerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iVisibilityCullerListener *) x));
}
static void *_p_iDocumentSystemTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iDocumentSystem *) x));
}
static void *_p_iReporterListenerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iReporterListener *) x));
}
static void *_p_iStandardReporterListenerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iStandardReporterListener *) x));
}
static void *_p_iCelTimerListenerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCelTimerListener *) x));
}
static void *_p_iPcMeshSelectListenerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcMeshSelectListener *) x));
}
static void *_p_iPcInventoryListenerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcInventoryListener *) x));
}
static void *_p_iPcSoundListenerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcSoundListener *) x));
}
static void *_p_iPcTimerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcTimer *) x));
}
static void *_p_iSndSysSourceSoftwareTo_p_iBase(void *x) {
    return (void *)((iBase *) (iSndSysSource *) ((iSndSysSourceSoftware *) x));
}
static void *_p_iSprite2DUVAnimationFrameTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSprite2DUVAnimationFrame *) x));
}
static void *_p_iTerraFormerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iTerraFormer *) x));
}
static void *_p_iSectorTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSector *) x));
}
static void *_p_iCelZoneTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCelZone *) x));
}
static void *_p_iSequenceTriggerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSequenceTrigger *) x));
}
static void *_p_iPortalContainerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPortalContainer *) x));
}
static void *_p_iAwsKeyContainerTo_p_iBase(void *x) {
    return (void *)((iBase *) (iAwsKey *) ((iAwsKeyContainer *) x));
}
static void *_p_iODESliderJointTo_p_iBase(void *x) {
    return (void *)((iBase *) (iODEGeneralJointState *) ((iODESliderJoint *) x));
}
static void *_p_iODEAMotorJointTo_p_iBase(void *x) {
    return (void *)((iBase *) (iODEGeneralJointState *) ((iODEAMotorJoint *) x));
}
static void *_p_iODEHinge2JointTo_p_iBase(void *x) {
    return (void *)((iBase *) (iODEGeneralJointState *) ((iODEHinge2Joint *) x));
}
static void *_p_iPcGravityTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcGravity *) x));
}
static void *_p_iCameraPositionListTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCameraPositionList *) x));
}
static void *_p_iRegionListTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iRegionList *) x));
}
static void *_p_iSpriteActionTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSpriteAction *) x));
}
static void *_p_iLightListTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iLightList *) x));
}
static void *_p_iMeshObjectDrawCallbackTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iMeshObjectDrawCallback *) x));
}
static void *_p_iLightCallbackTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iLightCallback *) x));
}
static void *_p_iSectorCallbackTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSectorCallback *) x));
}
static void *_p_iSectorMeshCallbackTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSectorMeshCallback *) x));
}
static void *_p_iLightVisibleCallbackTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iLightVisibleCallback *) x));
}
static void *_p_iEngineFrameCallbackTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iEngineFrameCallback *) x));
}
static void *_p_iEngineSectorCallbackTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iEngineSectorCallback *) x));
}
static void *_p_iTextureCallbackTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iTextureCallback *) x));
}
static void *_p_iMeshDrawCallbackTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iMeshDrawCallback *) x));
}
static void *_p_iPortalCallbackTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPortalCallback *) x));
}
static void *_p_iObjectTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iObject *) x));
}
static void *_p_iVisibilityObjectTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iVisibilityObject *) x));
}
static void *_p_iOffscreenCanvasCallbackTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iOffscreenCanvasCallback *) x));
}
static void *_p_iDynamicsMoveCallbackTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iDynamicsMoveCallback *) x));
}
static void *_p_iDynamicsCollisionCallbackTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iDynamicsCollisionCallback *) x));
}
static void *_p_iDynamicsColliderCollisionCallbackTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iDynamicsColliderCollisionCallback *) x));
}
static void *_p_iODEFrameUpdateCallbackTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iODEFrameUpdateCallback *) x));
}
static void *_p_iCelNewEntityCallbackTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCelNewEntityCallback *) x));
}
static void *_p_iCelEntityRemoveCallbackTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCelEntityRemoveCallback *) x));
}
static void *_p_iPcMechanicsObjectTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcMechanicsObject *) x));
}
static void *_p_iPcGravityCallbackTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcGravityCallback *) x));
}
static void *_p_iCameraTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCamera *) x));
}
static void *_p_iCommandLineParserTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCommandLineParser *) x));
}
static void *_p_iMeshFactoryListTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iMeshFactoryList *) x));
}
static void *_p_iPcCameraTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcCamera *) x));
}
static void *_p_iPcSimpleCameraTo_p_iBase(void *x) {
    return (void *)((iBase *) (iPcCamera *) ((iPcSimpleCamera *) x));
}
static void *_p_iVirtualClockTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iVirtualClock *) x));
}
static void *_p_iMeshObjectTypeTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iMeshObjectType *) x));
}
static void *_p_iGraphics3DTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iGraphics3D *) x));
}
static void *_p_iMovieRecorderTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iMovieRecorder *) x));
}
static void *_p_iSprite2DStateTo_p_iBase(void *x) {
    return (void *)((iBase *) (iSprite2DFactoryState *) ((iSprite2DState *) x));
}
static void *_p_iThingEnvironmentTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iThingEnvironment *) x));
}
static void *_p_iMovableTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iMovable *) x));
}
static void *_p_iPcMovableTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcMovable *) x));
}
static void *_p_iSectorListTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSectorList *) x));
}
static void *_p_iShaderVariableContextTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iShaderVariableContext *) x));
}
static void *_p_iSndSysSoftwareFilter3DTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSndSysSoftwareFilter3D *) x));
}
static void *_p_iCollideSystemTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCollideSystem *) x));
}
static void *_p_iDynamicSystemTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iDynamicSystem *) x));
}
static void *_p_iPcMechanicsSystemTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcMechanicsSystem *) x));
}
static void *_p_iShaderCompilerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iShaderCompiler *) x));
}
static void *_p_iLightingProcessDataTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iLightingProcessData *) x));
}
static void *_p_iCelEntityTrackerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCelEntityTracker *) x));
}
static void *_p_iCameraPositionTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCameraPosition *) x));
}
static void *_p_iBinaryLoaderPluginTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iBinaryLoaderPlugin *) x));
}
static void *_p_iLoaderPluginTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iLoaderPlugin *) x));
}
static void *_p_iHaloTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iHalo *) x));
}
static void *_p_iSpriteCal3DSocketTo_p_iBase(void *x) {
    return (void *)((iBase *) (iSpriteSocket *) ((iSpriteCal3DSocket *) x));
}
static void *_p_iSndSysStreamTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSndSysStream *) x));
}
static void *_p_iVisibilityCullerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iVisibilityCuller *) x));
}
static void *_p_iGeneralMeshCommonStateTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iGeneralMeshCommonState *) x));
}
static void *_p_iConfigFileTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iConfigFile *) x));
}
static void *_p_iEventQueueTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iEventQueue *) x));
}
static void *_p_iSoundSourceTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSoundSource *) x));
}
static void *_p_iRigidBodyTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iRigidBody *) x));
}
static void *_p_iPcSoundSourceTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcSoundSource *) x));
}
static void *_p_iEventOutletTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iEventOutlet *) x));
}
static void *_p_iAwsComponentNodeTo_p_iBase(void *x) {
    return (void *)((iBase *) (iAwsKey *)(iAwsKeyContainer *) ((iAwsComponentNode *) x));
}
static void *_p_iDocumentNodeTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iDocumentNode *) x));
}
static void *_p_iKeyboardDriverTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iKeyboardDriver *) x));
}
static void *_p_iSoundDriverTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSoundDriver *) x));
}
static void *_p_iSpriteCal3DStateTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSpriteCal3DState *) x));
}
static void *_p_iSprite3DStateTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSprite3DState *) x));
}
static void *_p_iBodyGroupTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iBodyGroup *) x));
}
static void *_p_iFrustumViewTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iFrustumView *) x));
}
static void *_p_iCelBehaviourTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCelBehaviour *) x));
}
static void *_p_iEventHandlerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iEventHandler *) x));
}
static void *_p_iAnimTimeUpdateHandlerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iAnimTimeUpdateHandler *) x));
}
static void *_p_iSoundLoaderTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSoundLoader *) x));
}
static void *_p__csPyEventHandlerTo_p_iBase(void *x) {
    return (void *)((iBase *) (iEventHandler *) ((_csPyEventHandler *) x));
}
static void *_p_iBillboardEventHandlerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iBillboardEventHandler *) x));
}
static void *_p_iPortalTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPortal *) x));
}
static void *_p_iPcTooltipTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcTooltip *) x));
}
static void *_p_iAwsTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iAws *) x));
}
static void *_p_iEngineSequenceParametersTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iEngineSequenceParameters *) x));
}
static void *_p_iAwsKeyTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iAwsKey *) x));
}
static void *_p_iGenMeshAnimationControlTypeTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iGenMeshAnimationControlType *) x));
}
static void *_p_iSoundRenderTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSoundRender *) x));
}
static void *_p_iFileTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iFile *) x));
}
static void *_p_iKeyComposerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iKeyComposer *) x));
}
static void *_p_iMaterialListTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iMaterialList *) x));
}
static void *_p_iAwsRectKeyTo_p_iBase(void *x) {
    return (void *)((iBase *) (iAwsKey *) ((iAwsRectKey *) x));
}
static void *_p_iLightingProcessInfoTo_p_iBase(void *x) {
    return (void *)((iBase *) (iFrustumViewUserdata *) ((iLightingProcessInfo *) x));
}
static void *_p_iSpriteSocketTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSpriteSocket *) x));
}
static void *_p_iPcActorMoveTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcActorMove *) x));
}
static void *_p_iSndSysRendererTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSndSysRenderer *) x));
}
static void *_p_iComponentTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iComponent *) x));
}
static void *_p_iAwsComponentTo_p_iBase(void *x) {
    return (void *)((iBase *) (iAwsSource *) ((iAwsComponent *) x));
}
static void *_p_iAwsStringKeyTo_p_iBase(void *x) {
    return (void *)((iBase *) (iAwsKey *) ((iAwsStringKey *) x));
}
static void *_p_iSndSysSourceTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSndSysSource *) x));
}
static void *_p_iAwsSourceTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iAwsSource *) x));
}
static void *_p_iCelEntityTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCelEntity *) x));
}
static void *_p_iVFSTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iVFS *) x));
}
static void *_p_iJoystickDriverTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iJoystickDriver *) x));
}
static void *_p_iMouseDriverTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iMouseDriver *) x));
}
static void *_p_iSndSysSoftwareDriverTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSndSysSoftwareDriver *) x));
}
static void *_p_iMeshObjectFactoryTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iMeshObjectFactory *) x));
}
static void *_p_iGenMeshAnimationControlFactoryTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iGenMeshAnimationControlFactory *) x));
}
static void *_p_iAwsConnectionNodeFactoryTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iAwsConnectionNodeFactory *) x));
}
static void *_p_iAwsKeyFactoryTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iAwsKeyFactory *) x));
}
static void *_p_iAwsComponentFactoryTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iAwsComponentFactory *) x));
}
static void *_p_iFactoryTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iFactory *) x));
}
static void *_p_iSndSysLoaderTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSndSysLoader *) x));
}
static void *_p_iLoaderTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iLoader *) x));
}
static void *_p_iFrustumViewUserdataTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iFrustumViewUserdata *) x));
}
static void *_p_iAwsSinkTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iAwsSink *) x));
}
static void *_p_iCelInventorySpaceTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCelInventorySpace *) x));
}
static void *_p_iShaderTo_p_iBase(void *x) {
    return (void *)((iBase *) (iShaderVariableContext *) ((iShader *) x));
}
static void *_p_iTextureListTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iTextureList *) x));
}
static void *_p_iNativeWindowTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iNativeWindow *) x));
}
static void *_p_iPcMechanicsJointTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcMechanicsJoint *) x));
}
static void *_p_iCelRegionTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCelRegion *) x));
}
static void *_p_iSpriteFrameTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSpriteFrame *) x));
}
static void *_p_iPcMechanicsBalancedGroupTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcMechanicsBalancedGroup *) x));
}
static void *_p_iFontDeleteNotifyTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iFontDeleteNotify *) x));
}
static void *_p_iThingStateTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iThingState *) x));
}
static void *_p_iAwsFloatKeyTo_p_iBase(void *x) {
    return (void *)((iBase *) (iAwsKey *) ((iAwsFloatKey *) x));
}
static void *_p_iPcMechanicsThrusterControllerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcMechanicsThrusterController *) x));
}
static void *_p_iJointTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iJoint *) x));
}
static void *_p_iFontTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iFont *) x));
}
static void *_p_iTerraSamplerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iTerraSampler *) x));
}
static void *_p_iSndSysSoftwareFilterOutputTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSndSysSoftwareFilterOutput *) x));
}
static void *_p_iAwsSlotTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iAwsSlot *) x));
}
static void *_p_iLightTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iLight *) x));
}
static void *_p_iViewTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iView *) x));
}
static void *_p_iCelInventorySpaceSlotTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCelInventorySpaceSlot *) x));
}
static void *_p_iColliderTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCollider *) x));
}
static void *_p_iDynamicsSystemColliderTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iDynamicsSystemCollider *) x));
}
static void *_p_iODEUniversalJointTo_p_iBase(void *x) {
    return (void *)((iBase *) (iODEGeneralJointState *) ((iODEUniversalJoint *) x));
}
static void *_p_iCelParameterBlockTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCelParameterBlock *) x));
}
static void *_p_iPcMeshSelectTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcMeshSelect *) x));
}
static void *_p_iSoundHandleTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSoundHandle *) x));
}
static void *_p_iPolygonHandleTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPolygonHandle *) x));
}
static void *_p_iObjectModelTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iObjectModel *) x));
}
static void *_p_iAwsConnectionKeyTo_p_iBase(void *x) {
    return (void *)((iBase *) (iAwsKey *) ((iAwsConnectionKey *) x));
}
static void *_p_iCelPropertyClassListTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCelPropertyClassList *) x));
}
static void *_p_iRegionTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iRegion *) x));
}
static void *_p_iStringSetTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iStringSet *) x));
}
static void *_p_iPcRegionTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcRegion *) x));
}
static void *_p_iCelMapFileTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCelMapFile *) x));
}
static void *_p_iConfigManagerTo_p_iBase(void *x) {
    return (void *)((iBase *) (iConfigFile *) ((iConfigManager *) x));
}
static void *_p_iPluginManagerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPluginManager *) x));
}
static void *_p_iCacheManagerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iCacheManager *) x));
}
static void *_p_iSndSysManagerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSndSysManager *) x));
}
static void *_p_iAwsLayoutManagerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iAwsLayoutManager *) x));
}
static void *_p_iAwsSinkManagerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iAwsSinkManager *) x));
}
static void *_p_iAwsPrefManagerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iAwsPrefManager *) x));
}
static void *_p_iNativeWindowManagerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iNativeWindowManager *) x));
}
static void *_p_iShaderManagerTo_p_iBase(void *x) {
    return (void *)((iBase *) (iShaderVariableContext *) ((iShaderManager *) x));
}
static void *_p_iTextureManagerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iTextureManager *) x));
}
static void *_p_iEngineSequenceManagerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iEngineSequenceManager *) x));
}
static void *_p_iBillboardManagerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iBillboardManager *) x));
}
static void *_p_iPcZoneManagerTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcZoneManager *) x));
}
static void *_p_iAwsPointKeyTo_p_iBase(void *x) {
    return (void *)((iBase *) (iAwsKey *) ((iAwsPointKey *) x));
}
static void *_p_iScriptTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iScript *) x));
}
static void *_p_iPcSolidTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcSolid *) x));
}
static void *_p_iSndSysDataTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iSndSysData *) x));
}
static void *_p_iPcMeshTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iPcMesh *) x));
}
static void *_p_iEventCordTo_p_iBase(void *x) {
    return (void *)((iBase *)  ((iEventCord *) x));
}
static void *_p_iPcDefaultCameraTo_p_iPcCamera(void *x) {
    return (void *)((iPcCamera *)  ((iPcDefaultCamera *) x));
}
static void *_p_iPcSimpleCameraTo_p_iPcCamera(void *x) {
    return (void *)((iPcCamera *)  ((iPcSimpleCamera *) x));
}
static swig_type_info _swigt__p_iCollider[] = {{"_p_iCollider", 0, "iCollider *", 0, 0, 0, 0},{"_p_iCollider", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_f_p_iMeshWrapper_p_iFrustumView_bool__void[] = {{"_p_f_p_iMeshWrapper_p_iFrustumView_bool__void", 0, "void (*)(iMeshWrapper *,iFrustumView *,bool)|csFrustumViewObjectFunc *", 0, 0, 0, 0},{"_p_f_p_iMeshWrapper_p_iFrustumView_bool__void", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iObjectRegistry[] = {{"_p_iObjectRegistry", 0, "iObjectRegistry *", 0, 0, 0, 0},{"_p_iObjectRegistry", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iDocumentNode[] = {{"_p_iDocumentNode", 0, "iDocumentNode *", 0, 0, 0, 0},{"_p_iDocumentNode", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcMovableConstraint[] = {{"_p_iPcMovableConstraint", 0, "iPcMovableConstraint *", 0, 0, 0, 0},{"_p_iPcMovableConstraint", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelPropertyClassList[] = {{"_p_iCelPropertyClassList", 0, "iCelPropertyClassList *", 0, 0, 0, 0},{"_p_iCelPropertyClassList", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_celPersistenceType[] = {{"_p_celPersistenceType", 0, "celPersistenceType *", 0, 0, 0, 0},{"_p_celPersistenceType", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_celInitializer[] = {{"_p_celInitializer", 0, "celInitializer *", 0, 0, 0, 0},{"_p_celInitializer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_csInitializer[] = {{"_p_csInitializer", 0, "csInitializer *", 0, 0, 0, 0},{"_p_csInitializer", 0, 0, 0, 0, 0, 0},{"_p_celInitializer", _p_celInitializerTo_p_csInitializer, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__std__size_t[] = {{"_std__size_t", 0, "std::size_t", 0, 0, 0, 0},{"_std__size_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__size_t[] = {{"_size_t", 0, "size_t", 0, 0, 0, 0},{"_size_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcDefaultCamera[] = {{"_p_iPcDefaultCamera", 0, "iPcDefaultCamera *", 0, 0, 0, 0},{"_p_iPcDefaultCamera", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelPropertyClassFactory[] = {{"_p_iCelPropertyClassFactory", 0, "iCelPropertyClassFactory *", 0, 0, 0, 0},{"_p_iCelPropertyClassFactory", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iSector[] = {{"_p_iSector", 0, "iSector *", 0, 0, 0, 0},{"_p_iSector", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_p_iSector[] = {{"_p_p_iSector", 0, "iSector **", 0, 0, 0, 0},{"_p_p_iSector", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_csArrayTcsImageIOFileFormatDescription_const_p_csArrayElementHandlerTcsImageIOFileFormatDescription_const_p_t_csArrayMemoryAllocatorTcsImageIOFileFormatDescription_const_p_t_t[] = {{"_p_csArrayTcsImageIOFileFormatDescription_const_p_csArrayElementHandlerTcsImageIOFileFormatDescription_const_p_t_csArrayMemoryAllocatorTcsImageIOFileFormatDescription_const_p_t_t", 0, "csArray<csImageIOFileFormatDescription const * > *|csImageIOFileFormatDescriptions *", 0, 0, 0, 0},{"_p_csArrayTcsImageIOFileFormatDescription_const_p_csArrayElementHandlerTcsImageIOFileFormatDescription_const_p_t_csArrayMemoryAllocatorTcsImageIOFileFormatDescription_const_p_t_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelParameterBlock[] = {{"_p_iCelParameterBlock", 0, "iCelParameterBlock *", 0, 0, 0, 0},{"_p_iCelParameterBlock", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_csPtrTiCelEntityList_t[] = {{"_p_csPtrTiCelEntityList_t", 0, "csPtr<iCelEntityList > *", 0, 0, 0, 0},{"_p_csPtrTiCelEntityList_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_bool[] = {{"_p_bool", 0, "bool *", 0, 0, 0, 0},{"_p_bool", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcCharacteristics[] = {{"_p_iPcCharacteristics", 0, "iPcCharacteristics *", 0, 0, 0, 0},{"_p_iPcCharacteristics", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p__csKeyModifierType[] = {{"_p__csKeyModifierType", 0, "enum _csKeyModifierType *|csKeyModifierType *", 0, 0, 0, 0},{"_p__csKeyModifierType", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_int8_t[] = {{"_p_int8_t", 0, "int8_t *|int8 *", 0, 0, 0, 0},{"_p_int8_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_uint8_t[] = {{"_p_uint8_t", 0, "uint8_t *|uint8 *", 0, 0, 0, 0},{"_p_uint8_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p__csKeyEventType[] = {{"_p__csKeyEventType", 0, "enum _csKeyEventType *|csKeyEventType *", 0, 0, 0, 0},{"_p__csKeyEventType", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p__csMouseEventType[] = {{"_p__csMouseEventType", 0, "enum _csMouseEventType *|csMouseEventType *", 0, 0, 0, 0},{"_p__csMouseEventType", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_csPtrTiCelMessage_t[] = {{"_p_csPtrTiCelMessage_t", 0, "csPtr<iCelMessage > *", 0, 0, 0, 0},{"_p_csPtrTiCelMessage_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p__csKeyCharType[] = {{"_p__csKeyCharType", 0, "enum _csKeyCharType *|csKeyCharType *", 0, 0, 0, 0},{"_p__csKeyCharType", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcMeshSelect[] = {{"_p_iPcMeshSelect", 0, "iPcMeshSelect *", 0, 0, 0, 0},{"_p_iPcMeshSelect", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p__csKeyModifiers[] = {{"_p__csKeyModifiers", 0, "_csKeyModifiers *|csKeyModifiers *", 0, 0, 0, 0},{"_p__csKeyModifiers", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcTooltip[] = {{"_p_iPcTooltip", 0, "iPcTooltip *", 0, 0, 0, 0},{"_p_iPcTooltip", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelEntityTracker[] = {{"_p_iCelEntityTracker", 0, "iCelEntityTracker *", 0, 0, 0, 0},{"_p_iCelEntityTracker", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_csColor[] = {{"_p_csColor", 0, "csColor *", 0, 0, 0, 0},{"_p_csColor", 0, 0, 0, 0, 0, 0},{"_p_csColor4", _p_csColor4To_p_csColor, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_int32_t[] = {{"_p_int32_t", 0, "int32_t *|csSoundSample *", 0, 0, 0, 0},{"_p_int32_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_uint32_t[] = {{"_p_uint32_t", 0, "uint32_t *|uint32 *", 0, 0, 0, 0},{"_p_uint32_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelEntity[] = {{"_p_iCelEntity", 0, "iCelEntity *", 0, 0, 0, 0},{"_p_iCelEntity", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelRegion[] = {{"_p_iCelRegion", 0, "iCelRegion *", 0, 0, 0, 0},{"_p_iCelRegion", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_void[] = {{"_p_void", 0, "void *", 0, 0, 0, 0},{"_p_void", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcLight[] = {{"_p_iPcLight", 0, "iPcLight *", 0, 0, 0, 0},{"_p_iPcLight", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_int[] = {{"_p_int", 0, "int *", 0, 0, 0, 0},{"_p_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_csPtrTiCelDataBuffer_t[] = {{"_p_csPtrTiCelDataBuffer_t", 0, "csPtr<iCelDataBuffer > *", 0, 0, 0, 0},{"_p_csPtrTiCelDataBuffer_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelMapFile[] = {{"_p_iCelMapFile", 0, "iCelMapFile *", 0, 0, 0, 0},{"_p_iCelMapFile", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPath[] = {{"_p_iPath", 0, "iPath *", 0, 0, 0, 0},{"_p_iPath", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iJoint[] = {{"_p_iJoint", 0, "iJoint *", 0, 0, 0, 0},{"_p_iJoint", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelEntityList[] = {{"_p_iCelEntityList", 0, "iCelEntityList *", 0, 0, 0, 0},{"_p_iCelEntityList", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_celData[] = {{"_p_celData", 0, "celData *", 0, 0, 0, 0},{"_p_celData", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iObject[] = {{"_p_iObject", 0, "iObject *", 0, 0, 0, 0},{"_p_iObject", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcMechanicsObject[] = {{"_p_iPcMechanicsObject", 0, "iPcMechanicsObject *", 0, 0, 0, 0},{"_p_iPcMechanicsObject", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_csHashTcsStrKey_csStrKey_t[] = {{"_p_csHashTcsStrKey_csStrKey_t", 0, "csHash<csStrKey,csStrKey > *|celEntityTemplateParams *", 0, 0, 0, 0},{"_p_csHashTcsStrKey_csStrKey_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iBillboard[] = {{"_p_iBillboard", 0, "iBillboard *", 0, 0, 0, 0},{"_p_iBillboard", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcBillboard[] = {{"_p_iPcBillboard", 0, "iPcBillboard *", 0, 0, 0, 0},{"_p_iPcBillboard", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcLinearMovement[] = {{"_p_iPcLinearMovement", 0, "iPcLinearMovement *", 0, 0, 0, 0},{"_p_iPcLinearMovement", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iSndSysSource[] = {{"_p_iSndSysSource", 0, "iSndSysSource *", 0, 0, 0, 0},{"_p_iSndSysSourceSoftware3D", _p_iSndSysSourceSoftware3DTo_p_iSndSysSource, 0, 0, 0, 0, 0},{"_p_iSndSysSource", 0, 0, 0, 0, 0, 0},{"_p_iSndSysSourceSoftware", _p_iSndSysSourceSoftwareTo_p_iSndSysSource, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_csString[] = {{"_p_csString", 0, "csString *", 0, 0, 0, 0},{"_p_csString", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iString[] = {{"_p_iString", 0, "iString *", 0, 0, 0, 0},{"_p_iString", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelEntityTemplate[] = {{"_p_iCelEntityTemplate", 0, "iCelEntityTemplate *", 0, 0, 0, 0},{"_p_iCelEntityTemplate", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iAwsComponent[] = {{"_p_iAwsComponent", 0, "iAwsComponent *|iAwsWindow *", 0, 0, 0, 0},{"_p_iAwsComponent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_csDirtyAccessArrayTcsSprite2DVertex_t[] = {{"_p_csDirtyAccessArrayTcsSprite2DVertex_t", 0, "csDirtyAccessArray<csSprite2DVertex > *|csColoredVertices *", 0, 0, 0, 0},{"_p_csDirtyAccessArrayTcsSprite2DVertex_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_csFlags[] = {{"_p_csFlags", 0, "csFlags *", 0, 0, 0, 0},{"_p_csFlags", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcCommandInput[] = {{"_p_iPcCommandInput", 0, "iPcCommandInput *", 0, 0, 0, 0},{"_p_iPcCommandInput", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_csOrthoTransform[] = {{"_p_csOrthoTransform", 0, "csOrthoTransform *", 0, 0, 0, 0},{"_p_csOrthoTransform", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelPropertyClass[] = {{"_p_iCelPropertyClass", 0, "iCelPropertyClass *", 0, 0, 0, 0},{"_p_iCelPropertyClass", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iStringArray[] = {{"_p_iStringArray", 0, "iStringArray *", 0, 0, 0, 0},{"_p_iStringArray", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcMovable[] = {{"_p_iPcMovable", 0, "iPcMovable *", 0, 0, 0, 0},{"_p_iPcMovable", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iBillboardEventHandler[] = {{"_p_iBillboardEventHandler", 0, "iBillboardEventHandler *", 0, 0, 0, 0},{"_p_iBillboardEventHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcCollisionDetection[] = {{"_p_iPcCollisionDetection", 0, "iPcCollisionDetection *", 0, 0, 0, 0},{"_p_iPcCollisionDetection", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_p_iPcCollisionDetection[] = {{"_p_p_iPcCollisionDetection", 0, "iPcCollisionDetection **", 0, 0, 0, 0},{"_p_p_iPcCollisionDetection", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__int[] = {{"_int", 0, "int|std::ptrdiff_t", 0, 0, 0, 0},{"_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p__csKeyModifierNumType[] = {{"_p__csKeyModifierNumType", 0, "enum _csKeyModifierNumType *|csKeyModifierNumType *", 0, 0, 0, 0},{"_p__csKeyModifierNumType", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_int16_t[] = {{"_p_int16_t", 0, "int16_t *|int16 *", 0, 0, 0, 0},{"_p_int16_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_uint16_t[] = {{"_p_uint16_t", 0, "uint16_t *|wint_t *", 0, 0, 0, 0},{"_p_uint16_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_uint64_t[] = {{"_p_uint64_t", 0, "uint64_t *|uintmax_t *", 0, 0, 0, 0},{"_p_uint64_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_int64_t[] = {{"_p_int64_t", 0, "int64_t *|intmax_t *", 0, 0, 0, 0},{"_p_int64_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcActorMove[] = {{"_p_iPcActorMove", 0, "iPcActorMove *", 0, 0, 0, 0},{"_p_iPcActorMove", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_char[] = {{"_p_char", 0, "char *", 0, 0, 0, 0},{"_p_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_FileFormatDescription[] = {{"_p_FileFormatDescription", 0, "FileFormatDescription *", 0, 0, 0, 0},{"_p_FileFormatDescription", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iMeshWrapper[] = {{"_p_iMeshWrapper", 0, "iMeshWrapper *", 0, 0, 0, 0},{"_p_iMeshWrapper", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iFont[] = {{"_p_iFont", 0, "iFont *", 0, 0, 0, 0},{"_p_iFont", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelPropertyChangeCallback[] = {{"_p_iCelPropertyChangeCallback", 0, "iCelPropertyChangeCallback *", 0, 0, 0, 0},{"_p_iCelPropertyChangeCallback", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelEntityRemoveCallback[] = {{"_p_iCelEntityRemoveCallback", 0, "iCelEntityRemoveCallback *", 0, 0, 0, 0},{"_p_iCelEntityRemoveCallback", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelNewEntityCallback[] = {{"_p_iCelNewEntityCallback", 0, "iCelNewEntityCallback *", 0, 0, 0, 0},{"_p_iCelNewEntityCallback", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcMechanicsBalancedGroup[] = {{"_p_iPcMechanicsBalancedGroup", 0, "iPcMechanicsBalancedGroup *", 0, 0, 0, 0},{"_p_iPcMechanicsBalancedGroup", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcGravityCallback[] = {{"_p_iPcGravityCallback", 0, "iPcGravityCallback *", 0, 0, 0, 0},{"_p_iPcGravityCallback", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iBillboardManager[] = {{"_p_iBillboardManager", 0, "iBillboardManager *", 0, 0, 0, 0},{"_p_iBillboardManager", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcZoneManager[] = {{"_p_iPcZoneManager", 0, "iPcZoneManager *", 0, 0, 0, 0},{"_p_iPcZoneManager", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_csArrayTcsPluginRequest_csArrayElementHandlerTcsPluginRequest_t_csArrayMemoryAllocatorTcsPluginRequest_t_t[] = {{"_p_csArrayTcsPluginRequest_csArrayElementHandlerTcsPluginRequest_t_csArrayMemoryAllocatorTcsPluginRequest_t_t", 0, "csArray<csPluginRequest > *", 0, 0, 0, 0},{"_p_csArrayTcsPluginRequest_csArrayElementHandlerTcsPluginRequest_t_csArrayMemoryAllocatorTcsPluginRequest_t_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCamera[] = {{"_p_iCamera", 0, "iCamera *", 0, 0, 0, 0},{"_p_iCamera", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcCamera[] = {{"_p_iPcCamera", 0, "iPcCamera *", 0, 0, 0, 0},{"_p_iPcDefaultCamera", _p_iPcDefaultCameraTo_p_iPcCamera, 0, 0, 0, 0, 0},{"_p_iPcCamera", 0, 0, 0, 0, 0, 0},{"_p_iPcSimpleCamera", _p_iPcSimpleCameraTo_p_iPcCamera, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcMesh[] = {{"_p_iPcMesh", 0, "iPcMesh *", 0, 0, 0, 0},{"_p_iPcMesh", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcSimpleCamera[] = {{"_p_iPcSimpleCamera", 0, "iPcSimpleCamera *", 0, 0, 0, 0},{"_p_iPcSimpleCamera", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_csArrayTcsShaderVariable_p_csArrayElementHandlerTcsShaderVariable_p_t_csArrayMemoryAllocatorTcsShaderVariable_p_t_t[] = {{"_p_csArrayTcsShaderVariable_p_csArrayElementHandlerTcsShaderVariable_p_t_csArrayMemoryAllocatorTcsShaderVariable_p_t_t", 0, "csArray<csShaderVariable * > *|csShaderVarStack *", 0, 0, 0, 0},{"_p_csArrayTcsShaderVariable_p_csArrayElementHandlerTcsShaderVariable_p_t_csArrayMemoryAllocatorTcsShaderVariable_p_t_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelBehaviour[] = {{"_p_iCelBehaviour", 0, "iCelBehaviour *", 0, 0, 0, 0},{"_p_iCelBehaviour", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_csPtrTiRigidBody_t[] = {{"_p_csPtrTiRigidBody_t", 0, "csPtr<iRigidBody > *", 0, 0, 0, 0},{"_p_csPtrTiRigidBody_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iBillboardLayer[] = {{"_p_iBillboardLayer", 0, "iBillboardLayer *", 0, 0, 0, 0},{"_p_iBillboardLayer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelZone[] = {{"_p_iCelZone", 0, "iCelZone *", 0, 0, 0, 0},{"_p_iCelZone", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcTimer[] = {{"_p_iPcTimer", 0, "iPcTimer *", 0, 0, 0, 0},{"_p_iPcTimer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcSoundSource[] = {{"_p_iPcSoundSource", 0, "iPcSoundSource *", 0, 0, 0, 0},{"_p_iPcSoundSource", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_csVector2[] = {{"_p_csVector2", 0, "csVector2 *", 0, 0, 0, 0},{"_p_csVector2", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_csPlane3[] = {{"_p_csPlane3", 0, "csPlane3 *", 0, 0, 0, 0},{"_p_csPlane3", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_unsigned_long[] = {{"_p_unsigned_long", 0, "unsigned long *|csStringID *", 0, 0, 0, 0},{"_p_unsigned_long", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelDataBuffer[] = {{"_p_iCelDataBuffer", 0, "iCelDataBuffer *", 0, 0, 0, 0},{"_p_iCelDataBuffer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_csVector3[] = {{"_p_csVector3", 0, "csVector3 *", 0, 0, 0, 0},{"_p_csVector3", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_celPersistenceResult[] = {{"_p_celPersistenceResult", 0, "celPersistenceResult *", 0, 0, 0, 0},{"_p_celPersistenceResult", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcMechanicsThruster[] = {{"_p_iPcMechanicsThruster", 0, "iPcMechanicsThruster *", 0, 0, 0, 0},{"_p_iPcMechanicsThruster", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcGravity[] = {{"_p_iPcGravity", 0, "iPcGravity *", 0, 0, 0, 0},{"_p_iPcGravity", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iRigidBody[] = {{"_p_iRigidBody", 0, "iRigidBody *", 0, 0, 0, 0},{"_p_iRigidBody", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_int_least64_t[] = {{"_p_int_least64_t", 0, "int_least64_t *|longlong *", 0, 0, 0, 0},{"_p_int_least64_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_uint_least64_t[] = {{"_p_uint_least64_t", 0, "uint_least64_t *|ulonglong *", 0, 0, 0, 0},{"_p_uint_least64_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iDynamicSystem[] = {{"_p_iDynamicSystem", 0, "iDynamicSystem *", 0, 0, 0, 0},{"_p_iDynamicSystem", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcMechanicsSystem[] = {{"_p_iPcMechanicsSystem", 0, "iPcMechanicsSystem *", 0, 0, 0, 0},{"_p_iPcMechanicsSystem", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcMechanicsJoint[] = {{"_p_iPcMechanicsJoint", 0, "iPcMechanicsJoint *", 0, 0, 0, 0},{"_p_iPcMechanicsJoint", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelInventorySpace[] = {{"_p_iCelInventorySpace", 0, "iCelInventorySpace *", 0, 0, 0, 0},{"_p_iCelInventorySpace", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_basetype[] = {{"_p_basetype", 0, "basetype *", 0, 0, 0, 0},{"_p_basetype", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_csRefArrayTiObject_t[] = {{"_p_csRefArrayTiObject_t", 0, "csRefArray<iObject > *|csObjectContainer *", 0, 0, 0, 0},{"_p_csRefArrayTiObject_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcSolid[] = {{"_p_iPcSolid", 0, "iPcSolid *", 0, 0, 0, 0},{"_p_iPcSolid", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_unsigned_int[] = {{"_p_unsigned_int", 0, "unsigned int *|uint *", 0, 0, 0, 0},{"_p_unsigned_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_csBox3[] = {{"_p_csBox3", 0, "csBox3 *", 0, 0, 0, 0},{"_p_csBox3", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iView[] = {{"_p_iView", 0, "iView *", 0, 0, 0, 0},{"_p_iView", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelInventorySpaceSlot[] = {{"_p_iCelInventorySpaceSlot", 0, "iCelInventorySpaceSlot *", 0, 0, 0, 0},{"_p_iCelInventorySpaceSlot", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_csPtrTiCelEntity_t[] = {{"_p_csPtrTiCelEntity_t", 0, "csPtr<iCelEntity > *", 0, 0, 0, 0},{"_p_csPtrTiCelEntity_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelTimerListener[] = {{"_p_iCelTimerListener", 0, "iCelTimerListener *", 0, 0, 0, 0},{"_p_iCelTimerListener", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcMeshSelectListener[] = {{"_p_iPcMeshSelectListener", 0, "iPcMeshSelectListener *", 0, 0, 0, 0},{"_p_iPcMeshSelectListener", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcInventoryListener[] = {{"_p_iPcInventoryListener", 0, "iPcInventoryListener *", 0, 0, 0, 0},{"_p_iPcInventoryListener", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcSoundListener[] = {{"_p_iPcSoundListener", 0, "iPcSoundListener *", 0, 0, 0, 0},{"_p_iPcSoundListener", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iSndSysListener[] = {{"_p_iSndSysListener", 0, "iSndSysListener *", 0, 0, 0, 0},{"_p_iSndSysListener", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_celDataType[] = {{"_p_celDataType", 0, "enum celDataType *|celDataType *", 0, 0, 0, 0},{"_p_celDataType", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p__csMouseCursorID[] = {{"_p__csMouseCursorID", 0, "enum _csMouseCursorID *|csMouseCursorID *", 0, 0, 0, 0},{"_p__csMouseCursorID", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcMechanicsThrusterController[] = {{"_p_iPcMechanicsThrusterController", 0, "iPcMechanicsThrusterController *", 0, 0, 0, 0},{"_p_iPcMechanicsThrusterController", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_float[] = {{"_p_float", 0, "float *", 0, 0, 0, 0},{"_p_float", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iBase[] = {{"_p_iBase", 0, "iBase *", 0, 0, 0, 0},{"_p_iAwsRGBKey", _p_iAwsRGBKeyTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iRendererLightmap", _p_iRendererLightmapTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSuperLightmap", _p_iSuperLightmapTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iConsoleOutput", _p_iConsoleOutputTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iTerrainObjectState", _p_iTerrainObjectStateTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iClipper2D", _p_iClipper2DTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iDebugHelper", _p_iDebugHelperTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iODEDynamicState", _p_iODEDynamicStateTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iDocumentAttribute", _p_iDocumentAttributeTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iODEHingeJoint", _p_iODEHingeJointTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iMaterialEngine", _p_iMaterialEngineTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcMovableConstraint", _p_iPcMovableConstraintTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iImageIO", _p_iImageIOTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iBillboardLayer", _p_iBillboardLayerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPath", _p_iPathTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iBillboard", _p_iBillboardTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcBillboard", _p_iPcBillboardTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSCF", _p_iSCFTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iLoaderStatus", _p_iLoaderStatusTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iODEBallJoint", _p_iODEBallJointTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcCharacteristics", _p_iPcCharacteristicsTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iTextureHandle", _p_iTextureHandleTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iGeneralMeshState", _p_iGeneralMeshStateTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iDynamics", _p_iDynamicsTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iParameterESM", _p_iParameterESMTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcCommandInput", _p_iPcCommandInputTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAwsIntKey", _p_iAwsIntKeyTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iODEDynamicSystemState", _p_iODEDynamicSystemStateTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iMeshList", _p_iMeshListTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iEventPlug", _p_iEventPlugTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCelPropertyClass", _p_iCelPropertyClassTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iODEGeneralJointState", _p_iODEGeneralJointStateTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iODEJointState", _p_iODEJointStateTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSndSysWrapper", _p_iSndSysWrapperTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSoundWrapper", _p_iSoundWrapperTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iTextureWrapper", _p_iTextureWrapperTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iMaterialWrapper", _p_iMaterialWrapperTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iMeshWrapper", _p_iMeshWrapperTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iMeshFactoryWrapper", _p_iMeshFactoryWrapperTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSequenceWrapper", _p_iSequenceWrapperTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iString", _p_iStringTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iConsoleWatcher", _p_iConsoleWatcherTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcInventory", _p_iPcInventoryTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcMechanicsThruster", _p_iPcMechanicsThrusterTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iEngine", _p_iEngineTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSimpleFormerState", _p_iSimpleFormerStateTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iMaterial", _p_iMaterialTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSprite2DUVAnimation", _p_iSprite2DUVAnimationTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPolygonMesh", _p_iPolygonMeshTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iTerrainFactoryState", _p_iTerrainFactoryStateTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iThingFactoryState", _p_iThingFactoryStateTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSpriteCal3DFactoryState", _p_iSpriteCal3DFactoryStateTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSprite3DFactoryState", _p_iSprite3DFactoryStateTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSprite2DFactoryState", _p_iSprite2DFactoryStateTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iGeneralFactoryState", _p_iGeneralFactoryStateTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iGraphics2D", _p_iGraphics2DTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iDocument", _p_iDocumentTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iShaderPriorityList", _p_iShaderPriorityListTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCelEntityList", _p_iCelEntityListTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSndSysSourceSoftware3D", _p_iSndSysSourceSoftware3DTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iDataBuffer", _p_iDataBufferTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iMeshObject", _p_iMeshObjectTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iScriptObject", _p_iScriptObjectTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcDefaultCamera", _p_iPcDefaultCameraTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSequenceTimedOperation", _p_iSequenceTimedOperationTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iHalo", _p_iHaloTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iFontServer", _p_iFontServerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iStringArray", _p_iStringArrayTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iReporter", _p_iReporterTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPluginIterator", _p_iPluginIteratorTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iConfigIterator", _p_iConfigIteratorTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iEventAttributeIterator", _p_iEventAttributeIteratorTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iObjectRegistryIterator", _p_iObjectRegistryIteratorTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iObjectIterator", _p_iObjectIteratorTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iLightIterator", _p_iLightIteratorTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSectorIterator", _p_iSectorIteratorTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iMeshWrapperIterator", _p_iMeshWrapperIteratorTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iReporterIterator", _p_iReporterIteratorTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iDocumentNodeIterator", _p_iDocumentNodeIteratorTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iDocumentAttributeIterator", _p_iDocumentAttributeIteratorTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iVisibilityObjectIterator", _p_iVisibilityObjectIteratorTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iMapNode", _p_iMapNodeTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iGenMeshAnimationControl", _p_iGenMeshAnimationControlTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iEventNameRegistry", _p_iEventNameRegistryTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iObjectRegistry", _p_iObjectRegistryTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCelPlLayer", _p_iCelPlLayerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCelBlLayer", _p_iCelBlLayerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcLinearMovement", _p_iPcLinearMovementTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iObjectNameChangeListener", _p_iObjectNameChangeListenerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSndSysListener", _p_iSndSysListenerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSoundListener", _p_iSoundListenerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iObjectModelListener", _p_iObjectModelListenerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCameraSectorListener", _p_iCameraSectorListenerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iMovableListener", _p_iMovableListenerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iVisibilityCullerListener", _p_iVisibilityCullerListenerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iReporterListener", _p_iReporterListenerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iStandardReporterListener", _p_iStandardReporterListenerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCelTimerListener", _p_iCelTimerListenerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcMeshSelectListener", _p_iPcMeshSelectListenerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcInventoryListener", _p_iPcInventoryListenerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcSoundListener", _p_iPcSoundListenerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iDocumentSystem", _p_iDocumentSystemTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcTimer", _p_iPcTimerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSndSysSourceSoftware", _p_iSndSysSourceSoftwareTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSprite2DUVAnimationFrame", _p_iSprite2DUVAnimationFrameTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iTerraFormer", _p_iTerraFormerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCelZone", _p_iCelZoneTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSector", _p_iSectorTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSequenceTrigger", _p_iSequenceTriggerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcGravity", _p_iPcGravityTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPortalContainer", _p_iPortalContainerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAwsKeyContainer", _p_iAwsKeyContainerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iODESliderJoint", _p_iODESliderJointTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iODEAMotorJoint", _p_iODEAMotorJointTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iODEHinge2Joint", _p_iODEHinge2JointTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCameraPositionList", _p_iCameraPositionListTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iRegionList", _p_iRegionListTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSpriteAction", _p_iSpriteActionTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iBase", 0, 0, 0, 0, 0, 0},{"_p_iLightList", _p_iLightListTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iFile", _p_iFileTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iMeshObjectDrawCallback", _p_iMeshObjectDrawCallbackTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iLightCallback", _p_iLightCallbackTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSectorCallback", _p_iSectorCallbackTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSectorMeshCallback", _p_iSectorMeshCallbackTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iLightVisibleCallback", _p_iLightVisibleCallbackTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iEngineFrameCallback", _p_iEngineFrameCallbackTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iEngineSectorCallback", _p_iEngineSectorCallbackTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iTextureCallback", _p_iTextureCallbackTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iMeshDrawCallback", _p_iMeshDrawCallbackTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPortalCallback", _p_iPortalCallbackTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iOffscreenCanvasCallback", _p_iOffscreenCanvasCallbackTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iDynamicsMoveCallback", _p_iDynamicsMoveCallbackTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iDynamicsCollisionCallback", _p_iDynamicsCollisionCallbackTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iDynamicsColliderCollisionCallback", _p_iDynamicsColliderCollisionCallbackTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iODEFrameUpdateCallback", _p_iODEFrameUpdateCallbackTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCelNewEntityCallback", _p_iCelNewEntityCallbackTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCelEntityRemoveCallback", _p_iCelEntityRemoveCallbackTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcGravityCallback", _p_iPcGravityCallbackTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iObject", _p_iObjectTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iVisibilityObject", _p_iVisibilityObjectTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcMechanicsObject", _p_iPcMechanicsObjectTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCamera", _p_iCameraTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcCamera", _p_iPcCameraTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcSimpleCamera", _p_iPcSimpleCameraTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCommandLineParser", _p_iCommandLineParserTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iMeshFactoryList", _p_iMeshFactoryListTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iGraphics3D", _p_iGraphics3DTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iVirtualClock", _p_iVirtualClockTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iMeshObjectType", _p_iMeshObjectTypeTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iMovieRecorder", _p_iMovieRecorderTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSprite2DState", _p_iSprite2DStateTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iThingEnvironment", _p_iThingEnvironmentTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iMovable", _p_iMovableTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcMovable", _p_iPcMovableTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAws", _p_iAwsTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iShaderVariableContext", _p_iShaderVariableContextTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSectorList", _p_iSectorListTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSndSysSoftwareFilter3D", _p_iSndSysSoftwareFilter3DTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCollideSystem", _p_iCollideSystemTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iDynamicSystem", _p_iDynamicSystemTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcMechanicsSystem", _p_iPcMechanicsSystemTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iShaderCompiler", _p_iShaderCompilerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iLightingProcessData", _p_iLightingProcessDataTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCelEntityTracker", _p_iCelEntityTrackerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCameraPosition", _p_iCameraPositionTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iBinaryLoaderPlugin", _p_iBinaryLoaderPluginTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iLoaderPlugin", _p_iLoaderPluginTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSpriteCal3DSocket", _p_iSpriteCal3DSocketTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSndSysStream", _p_iSndSysStreamTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iVisibilityCuller", _p_iVisibilityCullerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iGeneralMeshCommonState", _p_iGeneralMeshCommonStateTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iConfigFile", _p_iConfigFileTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iEventQueue", _p_iEventQueueTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iVFS", _p_iVFSTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSoundSource", _p_iSoundSourceTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iRigidBody", _p_iRigidBodyTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcSoundSource", _p_iPcSoundSourceTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iEventOutlet", _p_iEventOutletTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAwsComponentNode", _p_iAwsComponentNodeTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iDocumentNode", _p_iDocumentNodeTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iFont", _p_iFontTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iKeyboardDriver", _p_iKeyboardDriverTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSoundDriver", _p_iSoundDriverTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSpriteCal3DState", _p_iSpriteCal3DStateTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSprite3DState", _p_iSprite3DStateTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iBodyGroup", _p_iBodyGroupTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iFrustumView", _p_iFrustumViewTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCelBehaviour", _p_iCelBehaviourTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iEventHandler", _p_iEventHandlerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAnimTimeUpdateHandler", _p_iAnimTimeUpdateHandlerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSoundLoader", _p_iSoundLoaderTo_p_iBase, 0, 0, 0, 0, 0},{"_p__csPyEventHandler", _p__csPyEventHandlerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iBillboardEventHandler", _p_iBillboardEventHandlerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPortal", _p_iPortalTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcTooltip", _p_iPcTooltipTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iEngineSequenceParameters", _p_iEngineSequenceParametersTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAwsKey", _p_iAwsKeyTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iView", _p_iViewTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iGenMeshAnimationControlType", _p_iGenMeshAnimationControlTypeTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSoundRender", _p_iSoundRenderTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iKeyComposer", _p_iKeyComposerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iMaterialList", _p_iMaterialListTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAwsRectKey", _p_iAwsRectKeyTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iLightingProcessInfo", _p_iLightingProcessInfoTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iJoint", _p_iJointTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSpriteSocket", _p_iSpriteSocketTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcActorMove", _p_iPcActorMoveTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSndSysRenderer", _p_iSndSysRendererTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iComponent", _p_iComponentTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAwsComponent", _p_iAwsComponentTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iLight", _p_iLightTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAwsStringKey", _p_iAwsStringKeyTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSndSysSource", _p_iSndSysSourceTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAwsSource", _p_iAwsSourceTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCelEntity", _p_iCelEntityTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iJoystickDriver", _p_iJoystickDriverTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iMouseDriver", _p_iMouseDriverTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSndSysSoftwareDriver", _p_iSndSysSoftwareDriverTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iMeshObjectFactory", _p_iMeshObjectFactoryTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iGenMeshAnimationControlFactory", _p_iGenMeshAnimationControlFactoryTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAwsConnectionNodeFactory", _p_iAwsConnectionNodeFactoryTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAwsKeyFactory", _p_iAwsKeyFactoryTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAwsComponentFactory", _p_iAwsComponentFactoryTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iFactory", _p_iFactoryTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSndSysLoader", _p_iSndSysLoaderTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iLoader", _p_iLoaderTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iFrustumViewUserdata", _p_iFrustumViewUserdataTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAwsSink", _p_iAwsSinkTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCelInventorySpace", _p_iCelInventorySpaceTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iShader", _p_iShaderTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iTextureList", _p_iTextureListTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iNativeWindow", _p_iNativeWindowTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcMechanicsJoint", _p_iPcMechanicsJointTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCelRegion", _p_iCelRegionTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSpriteFrame", _p_iSpriteFrameTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcMechanicsBalancedGroup", _p_iPcMechanicsBalancedGroupTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iFontDeleteNotify", _p_iFontDeleteNotifyTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iThingState", _p_iThingStateTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAwsFloatKey", _p_iAwsFloatKeyTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcMechanicsThrusterController", _p_iPcMechanicsThrusterControllerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iTerraSampler", _p_iTerraSamplerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iEvent", _p_iEventTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSndSysSoftwareFilterOutput", _p_iSndSysSoftwareFilterOutputTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAwsSlot", _p_iAwsSlotTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCelInventorySpaceSlot", _p_iCelInventorySpaceSlotTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iImage", _p_iImageTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCollider", _p_iColliderTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iDynamicsSystemCollider", _p_iDynamicsSystemColliderTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iODEUniversalJoint", _p_iODEUniversalJointTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCelParameterBlock", _p_iCelParameterBlockTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcMeshSelect", _p_iPcMeshSelectTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSoundHandle", _p_iSoundHandleTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPolygonHandle", _p_iPolygonHandleTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iObjectModel", _p_iObjectModelTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAwsConnectionKey", _p_iAwsConnectionKeyTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCelPropertyClassList", _p_iCelPropertyClassListTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iRegion", _p_iRegionTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iStringSet", _p_iStringSetTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcRegion", _p_iPcRegionTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCelMapFile", _p_iCelMapFileTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iConfigManager", _p_iConfigManagerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPluginManager", _p_iPluginManagerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iCacheManager", _p_iCacheManagerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSndSysManager", _p_iSndSysManagerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAwsLayoutManager", _p_iAwsLayoutManagerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAwsSinkManager", _p_iAwsSinkManagerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAwsPrefManager", _p_iAwsPrefManagerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iNativeWindowManager", _p_iNativeWindowManagerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iShaderManager", _p_iShaderManagerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iTextureManager", _p_iTextureManagerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iEngineSequenceManager", _p_iEngineSequenceManagerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iBillboardManager", _p_iBillboardManagerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcZoneManager", _p_iPcZoneManagerTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iAwsPointKey", _p_iAwsPointKeyTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iScript", _p_iScriptTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcSolid", _p_iPcSolidTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSaver", _p_iSaverTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iSndSysData", _p_iSndSysDataTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iPcMesh", _p_iPcMeshTo_p_iBase, 0, 0, 0, 0, 0},{"_p_iEventCord", _p_iEventCordTo_p_iBase, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelBlLayer[] = {{"_p_iCelBlLayer", 0, "iCelBlLayer *", 0, 0, 0, 0},{"_p_iCelBlLayer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iCelPlLayer[] = {{"_p_iCelPlLayer", 0, "iCelPlLayer *", 0, 0, 0, 0},{"_p_iCelPlLayer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcInventory[] = {{"_p_iPcInventory", 0, "iPcInventory *", 0, 0, 0, 0},{"_p_iPcInventory", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iPcRegion[] = {{"_p_iPcRegion", 0, "iPcRegion *", 0, 0, 0, 0},{"_p_iPcRegion", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
static swig_type_info _swigt__p_iRegion[] = {{"_p_iRegion", 0, "iRegion *", 0, 0, 0, 0},{"_p_iRegion", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};

static swig_type_info *swig_types_initial[] = {
_swigt__p_iCollider, 
_swigt__p_f_p_iMeshWrapper_p_iFrustumView_bool__void, 
_swigt__p_iObjectRegistry, 
_swigt__p_iDocumentNode, 
_swigt__p_iPcMovableConstraint, 
_swigt__p_iCelPropertyClassList, 
_swigt__p_celPersistenceType, 
_swigt__p_celInitializer, 
_swigt__p_csInitializer, 
_swigt__std__size_t, 
_swigt__size_t, 
_swigt__p_iPcDefaultCamera, 
_swigt__p_iCelPropertyClassFactory, 
_swigt__p_iSector, 
_swigt__p_p_iSector, 
_swigt__p_csArrayTcsImageIOFileFormatDescription_const_p_csArrayElementHandlerTcsImageIOFileFormatDescription_const_p_t_csArrayMemoryAllocatorTcsImageIOFileFormatDescription_const_p_t_t, 
_swigt__p_iCelParameterBlock, 
_swigt__p_csPtrTiCelEntityList_t, 
_swigt__p_bool, 
_swigt__p_iPcCharacteristics, 
_swigt__p__csKeyModifierType, 
_swigt__p_int8_t, 
_swigt__p_uint8_t, 
_swigt__p__csKeyEventType, 
_swigt__p__csMouseEventType, 
_swigt__p_csPtrTiCelMessage_t, 
_swigt__p__csKeyCharType, 
_swigt__p_iPcMeshSelect, 
_swigt__p__csKeyModifiers, 
_swigt__p_iPcTooltip, 
_swigt__p_iCelEntityTracker, 
_swigt__p_csColor, 
_swigt__p_int32_t, 
_swigt__p_uint32_t, 
_swigt__p_iCelEntity, 
_swigt__p_iCelRegion, 
_swigt__p_void, 
_swigt__p_iPcLight, 
_swigt__p_int, 
_swigt__p_csPtrTiCelDataBuffer_t, 
_swigt__p_iCelMapFile, 
_swigt__p_iPath, 
_swigt__p_iJoint, 
_swigt__p_iCelEntityList, 
_swigt__p_celData, 
_swigt__p_iObject, 
_swigt__p_iPcMechanicsObject, 
_swigt__p_csHashTcsStrKey_csStrKey_t, 
_swigt__p_iBillboard, 
_swigt__p_iPcBillboard, 
_swigt__p_iPcLinearMovement, 
_swigt__p_iSndSysSource, 
_swigt__p_csString, 
_swigt__p_iString, 
_swigt__p_iCelEntityTemplate, 
_swigt__p_iAwsComponent, 
_swigt__p_csDirtyAccessArrayTcsSprite2DVertex_t, 
_swigt__p_csFlags, 
_swigt__p_iPcCommandInput, 
_swigt__p_csOrthoTransform, 
_swigt__p_iCelPropertyClass, 
_swigt__p_iStringArray, 
_swigt__p_iPcMovable, 
_swigt__p_iBillboardEventHandler, 
_swigt__p_iPcCollisionDetection, 
_swigt__p_p_iPcCollisionDetection, 
_swigt__int, 
_swigt__p__csKeyModifierNumType, 
_swigt__p_int16_t, 
_swigt__p_uint16_t, 
_swigt__p_uint64_t, 
_swigt__p_int64_t, 
_swigt__p_iPcActorMove, 
_swigt__p_char, 
_swigt__p_FileFormatDescription, 
_swigt__p_iMeshWrapper, 
_swigt__p_iFont, 
_swigt__p_iCelPropertyChangeCallback, 
_swigt__p_iCelEntityRemoveCallback, 
_swigt__p_iCelNewEntityCallback, 
_swigt__p_iPcMechanicsBalancedGroup, 
_swigt__p_iPcGravityCallback, 
_swigt__p_iBillboardManager, 
_swigt__p_iPcZoneManager, 
_swigt__p_csArrayTcsPluginRequest_csArrayElementHandlerTcsPluginRequest_t_csArrayMemoryAllocatorTcsPluginRequest_t_t, 
_swigt__p_iCamera, 
_swigt__p_iPcCamera, 
_swigt__p_iPcMesh, 
_swigt__p_iPcSimpleCamera, 
_swigt__p_csArrayTcsShaderVariable_p_csArrayElementHandlerTcsShaderVariable_p_t_csArrayMemoryAllocatorTcsShaderVariable_p_t_t, 
_swigt__p_iCelBehaviour, 
_swigt__p_csPtrTiRigidBody_t, 
_swigt__p_iBillboardLayer, 
_swigt__p_iCelZone, 
_swigt__p_iPcTimer, 
_swigt__p_iPcSoundSource, 
_swigt__p_csVector2, 
_swigt__p_csPlane3, 
_swigt__p_unsigned_long, 
_swigt__p_iCelDataBuffer, 
_swigt__p_csVector3, 
_swigt__p_celPersistenceResult, 
_swigt__p_iPcMechanicsThruster, 
_swigt__p_iPcGravity, 
_swigt__p_iRigidBody, 
_swigt__p_int_least64_t, 
_swigt__p_uint_least64_t, 
_swigt__p_iDynamicSystem, 
_swigt__p_iPcMechanicsSystem, 
_swigt__p_iPcMechanicsJoint, 
_swigt__p_iCelInventorySpace, 
_swigt__p_basetype, 
_swigt__p_csRefArrayTiObject_t, 
_swigt__p_iPcSolid, 
_swigt__p_unsigned_int, 
_swigt__p_csBox3, 
_swigt__p_iView, 
_swigt__p_iCelInventorySpaceSlot, 
_swigt__p_csPtrTiCelEntity_t, 
_swigt__p_iCelTimerListener, 
_swigt__p_iPcMeshSelectListener, 
_swigt__p_iPcInventoryListener, 
_swigt__p_iPcSoundListener, 
_swigt__p_iSndSysListener, 
_swigt__p_celDataType, 
_swigt__p__csMouseCursorID, 
_swigt__p_iPcMechanicsThrusterController, 
_swigt__p_float, 
_swigt__p_iBase, 
_swigt__p_iCelBlLayer, 
_swigt__p_iCelPlLayer, 
_swigt__p_iPcInventory, 
_swigt__p_iPcRegion, 
_swigt__p_iRegion, 
0
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};

#ifdef __cplusplus
}
#endif


#ifdef __cplusplus
extern "C" {
#endif
    
    /* Python-specific SWIG API */
#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
    
    /* -----------------------------------------------------------------------------
     * global variable support code.
     * ----------------------------------------------------------------------------- */
    
    typedef struct swig_globalvar {
        char       *name;                  /* Name of global variable */
        PyObject *(*get_attr)();           /* Return the current value */
        int       (*set_attr)(PyObject *); /* Set the value */
        struct swig_globalvar *next;
    } swig_globalvar;
    
    typedef struct swig_varlinkobject {
        PyObject_HEAD
        swig_globalvar *vars;
    } swig_varlinkobject;
    
    static PyObject *
    swig_varlink_repr(swig_varlinkobject *v) {
        v = v;
        return PyString_FromString("<Swig global variables>");
    }
    
    static int
    swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
        swig_globalvar  *var;
        flags = flags;
        fprintf(fp,"Swig global variables { ");
        for (var = v->vars; var; var=var->next) {
            fprintf(fp,"%s", var->name);
            if (var->next) fprintf(fp,", ");
        }
        fprintf(fp," }\n");
        return 0;
    }
    
    static PyObject *
    swig_varlink_getattr(swig_varlinkobject *v, char *n) {
        swig_globalvar *var = v->vars;
        while (var) {
            if (strcmp(var->name,n) == 0) {
                return (*var->get_attr)();
            }
            var = var->next;
        }
        PyErr_SetString(PyExc_NameError,"Unknown C global variable");
        return NULL;
    }
    
    static int
    swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
        swig_globalvar *var = v->vars;
        while (var) {
            if (strcmp(var->name,n) == 0) {
                return (*var->set_attr)(p);
            }
            var = var->next;
        }
        PyErr_SetString(PyExc_NameError,"Unknown C global variable");
        return 1;
    }
    
    static PyTypeObject varlinktype = {
        PyObject_HEAD_INIT(0)              
        0,                                  /* Number of items in variable part (ob_size) */
        (char *)"swigvarlink",              /* Type name (tp_name) */
        sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
        0,                                  /* Itemsize (tp_itemsize) */
        0,                                  /* Deallocator (tp_dealloc) */ 
        (printfunc) swig_varlink_print,     /* Print (tp_print) */
        (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
        (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
        0,                                  /* tp_compare */
        (reprfunc) swig_varlink_repr,       /* tp_repr */
        0,                                  /* tp_as_number */
        0,                                  /* tp_as_sequence */
        0,                                  /* tp_as_mapping */
        0,                                  /* tp_hash */
        0,                                  /* tp_call */
        0,                                  /* tp_str */
        0,                                  /* tp_getattro */
        0,                                  /* tp_setattro */
        0,                                  /* tp_as_buffer */
        0,                                  /* tp_flags */
        0,                                  /* tp_doc */
#if PY_VERSION_HEX >= 0x02000000
        0,                                  /* tp_traverse */
        0,                                  /* tp_clear */
#endif
#if PY_VERSION_HEX >= 0x02010000
        0,                                  /* tp_richcompare */
        0,                                  /* tp_weaklistoffset */
#endif
#if PY_VERSION_HEX >= 0x02020000
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
        0,                                  /* tp_del */
#endif
#ifdef COUNT_ALLOCS
        0,0,0,0                             /* tp_alloc -> tp_next */
#endif
    };
    
    /* Create a variable linking object for use later */
    static PyObject *
    SWIG_Python_newvarlink(void) {
        swig_varlinkobject *result = 0;
        result = PyMem_NEW(swig_varlinkobject,1);
        varlinktype.ob_type = &PyType_Type;    /* Patch varlinktype into a PyType */
        result->ob_type = &varlinktype;
        result->vars = 0;
        result->ob_refcnt = 0;
        Py_XINCREF((PyObject *) result);
        return ((PyObject*) result);
    }
    
    static void
    SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
        swig_varlinkobject *v;
        swig_globalvar *gv;
        v= (swig_varlinkobject *) p;
        gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
        gv->name = (char *) malloc(strlen(name)+1);
        strcpy(gv->name,name);
        gv->get_attr = get_attr;
        gv->set_attr = set_attr;
        gv->next = v->vars;
        v->vars = gv;
    }
    
    /* -----------------------------------------------------------------------------
     * constants/methods manipulation
     * ----------------------------------------------------------------------------- */
    
    /* Install Constants */
    static void
    SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
        PyObject *obj = 0;
        size_t i;
        for (i = 0; constants[i].type; i++) {
            switch(constants[i].type) {
                case SWIG_PY_INT:
                obj = PyInt_FromLong(constants[i].lvalue);
                break;
                case SWIG_PY_FLOAT:
                obj = PyFloat_FromDouble(constants[i].dvalue);
                break;
                case SWIG_PY_STRING:
                if (constants[i].pvalue) {
                    obj = PyString_FromString((char *) constants[i].pvalue);
                } else {
                    Py_INCREF(Py_None);
                    obj = Py_None;
                }
                break;
                case SWIG_PY_POINTER:
                obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
                break;
                case SWIG_PY_BINARY:
                obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
                break;
                default:
                obj = 0;
                break;
            }
            if (obj) {
                PyDict_SetItemString(d,constants[i].name,obj);
                Py_DECREF(obj);
            }
        }
    }
    
    /* -----------------------------------------------------------------------------*/
    /* Fix SwigMethods to carry the callback ptrs when needed */
    /* -----------------------------------------------------------------------------*/
    
    static void
    SWIG_Python_FixMethods(PyMethodDef *methods,
    swig_const_info *const_table,
    swig_type_info **types,
    swig_type_info **types_initial) {
        size_t i;
        for (i = 0; methods[i].ml_name; ++i) {
            char *c = methods[i].ml_doc;
            if (c && (c = strstr(c, "swig_ptr: "))) {
                int j;
                swig_const_info *ci = 0;
                char *name = c + 10;
                for (j = 0; const_table[j].type; j++) {
                    if (strncmp(const_table[j].name, name, 
                    strlen(const_table[j].name)) == 0) {
                        ci = &(const_table[j]);
                        break;
                    }
                }
                if (ci) {
                    size_t shift = (ci->ptype) - types;
                    swig_type_info *ty = types_initial[shift];
                    size_t ldoc = (c - methods[i].ml_doc);
                    size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
                    char *ndoc = (char*)malloc(ldoc + lptr + 10);
                    char *buff = ndoc;
                    void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
                    strncpy(buff, methods[i].ml_doc, ldoc);
                    buff += ldoc;
                    strncpy(buff, "swig_ptr: ", 10);
                    buff += 10;
                    SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
                    methods[i].ml_doc = ndoc;
                }
            }
        }
    }
    
    /* -----------------------------------------------------------------------------*
     *  Initialize type list
     * -----------------------------------------------------------------------------*/
    
#if PY_MAJOR_VERSION < 2
    /* PyModule_AddObject function was introduced in Python 2.0.  The following function
    is copied out of Python/modsupport.c in python version 2.3.4 */
    static int
    PyModule_AddObject(PyObject *m, char *name, PyObject *o)
    {
        PyObject *dict;
        if (!PyModule_Check(m)) {
            PyErr_SetString(PyExc_TypeError,
            "PyModule_AddObject() needs module as first arg");
            return -1;
        }
        if (!o) {
            PyErr_SetString(PyExc_TypeError,
            "PyModule_AddObject() needs non-NULL value");
            return -1;
        }
        
        dict = PyModule_GetDict(m);
        if (dict == NULL) {
            /* Internal error -- modules must have a dict! */
            PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
            PyModule_GetName(m));
            return -1;
        }
        if (PyDict_SetItemString(dict, name, o))
        return -1;
        Py_DECREF(o);
        return 0;
    }
#endif
    
    static swig_type_info **
    SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
        static PyMethodDef swig_empty_runtime_method_table[] = {
            {
                NULL, NULL, 0, NULL
            } 
        };/* Sentinel */
        
        PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
        swig_empty_runtime_method_table);
        PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
        if (pointer && module) {
            PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
        }
        return type_list_handle;
    } 
    
    static swig_type_info **
    SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
        swig_type_info **type_pointer;
        
        /* first check if module already created */
        type_pointer = SWIG_Python_GetTypeListHandle();
        if (type_pointer) {
            return type_pointer;
        } else {
            /* create a new module and variable */
            return SWIG_Python_SetTypeListHandle(type_list_handle);
        }
    }
    
#ifdef __cplusplus
}
#endif

/* -----------------------------------------------------------------------------*
 *  Partial Init method
 * -----------------------------------------------------------------------------*/

#ifdef SWIG_LINK_RUNTIME
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
#endif

#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT(void) SWIG_init(void) {
    static PyObject *SWIG_globals = 0; 
    static int       typeinit = 0;
    PyObject *m, *d;
    int       i;
    if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
    
    /* Fix SwigMethods to carry the callback ptrs when needed */
    SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
    
    m = Py_InitModule((char *) SWIG_name, SwigMethods);
    d = PyModule_GetDict(m);
    
    if (!typeinit) {
#ifdef SWIG_LINK_RUNTIME
        swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
#else
#  ifndef SWIG_STATIC_RUNTIME
        swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
#  endif
#endif
        for (i = 0; swig_types_initial[i]; i++) {
            swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
        }
        typeinit = 1;
    }
    SWIG_InstallConstants(d,swig_const_table);
    
    {
        PyDict_SetItemString(d,"CEL_EVENT_PRE", SWIG_From_int((int)(0))); 
    }
    {
        PyDict_SetItemString(d,"CEL_EVENT_VIEW", SWIG_From_int((int)(1))); 
    }
    {
        PyDict_SetItemString(d,"CEL_EVENT_POST", SWIG_From_int((int)(2))); 
    }
    {
        PyDict_SetItemString(d,"CEL_AT_NONE", SWIG_From_int((int)(CEL_AT_NONE))); 
    }
    {
        PyDict_SetItemString(d,"CEL_AT_ROTATION", SWIG_From_int((int)(CEL_AT_ROTATION))); 
    }
    {
        PyDict_SetItemString(d,"CEL_AT_TRANSLATION", SWIG_From_int((int)(CEL_AT_TRANSLATION))); 
    }
    {
        PyDict_SetItemString(d,"CEL_BILLBOARD_VISIBLE", SWIG_From_int((int)(1))); 
    }
    {
        PyDict_SetItemString(d,"CEL_BILLBOARD_MOVABLE", SWIG_From_int((int)(2))); 
    }
    {
        PyDict_SetItemString(d,"CEL_BILLBOARD_CLICKABLE", SWIG_From_int((int)(4))); 
    }
    {
        PyDict_SetItemString(d,"CEL_BILLBOARD_RESTACK", SWIG_From_int((int)(8))); 
    }
    {
        PyDict_SetItemString(d,"CEL_ZONEERROR_OK", SWIG_From_int((int)(0))); 
    }
    {
        PyDict_SetItemString(d,"CEL_ZONEERROR_BADREGION", SWIG_From_int((int)(1))); 
    }
    {
        PyDict_SetItemString(d,"CEL_ZONEERROR_BADSTART", SWIG_From_int((int)(2))); 
    }
    {
        PyDict_SetItemString(d,"CEL_ZONEERROR_LOAD", SWIG_From_int((int)(3))); 
    }
    {
        PyDict_SetItemString(d,"CEL_ZONE_NORMAL", SWIG_From_int((int)(0))); 
    }
    {
        PyDict_SetItemString(d,"CEL_ZONE_KEEP", SWIG_From_int((int)(1))); 
    }
    {
        PyDict_SetItemString(d,"CEL_ZONE_LOADALL", SWIG_From_int((int)(2))); 
    }
    {
        PyDict_SetItemString(d,"iPcDefaultCamera_freelook", SWIG_From_int((int)(iPcDefaultCamera::freelook))); 
    }
    {
        PyDict_SetItemString(d,"iPcDefaultCamera_firstperson", SWIG_From_int((int)(iPcDefaultCamera::firstperson))); 
    }
    {
        PyDict_SetItemString(d,"iPcDefaultCamera_thirdperson", SWIG_From_int((int)(iPcDefaultCamera::thirdperson))); 
    }
    {
        PyDict_SetItemString(d,"iPcDefaultCamera_m64_thirdperson", SWIG_From_int((int)(iPcDefaultCamera::m64_thirdperson))); 
    }
    {
        PyDict_SetItemString(d,"iPcDefaultCamera_lara_thirdperson", SWIG_From_int((int)(iPcDefaultCamera::lara_thirdperson))); 
    }
    {
        PyDict_SetItemString(d,"iPcDefaultCamera_actual_data", SWIG_From_int((int)(iPcDefaultCamera::actual_data))); 
    }
    {
        PyDict_SetItemString(d,"iPcDefaultCamera_last_actual", SWIG_From_int((int)(iPcDefaultCamera::last_actual))); 
    }
    {
        PyDict_SetItemString(d,"iPcDefaultCamera_transition", SWIG_From_int((int)(iPcDefaultCamera::transition))); 
    }
    {
        PyDict_SetItemString(d,"iPcDefaultCamera_camerror", SWIG_From_int((int)(iPcDefaultCamera::camerror))); 
    }
    {
        PyDict_SetItemString(d,"iPcDefaultCamera_CameraMode_count", SWIG_From_int((int)(iPcDefaultCamera::CameraMode_count))); 
    }
    {
        PyDict_SetItemString(d,"CEL_MOUSE_BUTTON1", SWIG_From_int((int)(1))); 
    }
    {
        PyDict_SetItemString(d,"CEL_MOUSE_BUTTON2", SWIG_From_int((int)(2))); 
    }
    {
        PyDict_SetItemString(d,"CEL_MOUSE_BUTTON3", SWIG_From_int((int)(4))); 
    }
    {
        PyDict_SetItemString(d,"CEL_PCMESH_PROPERTY_MESH", SWIG_From_int((int)(1))); 
    }
    {
        PyDict_SetItemString(d,"CEL_PCMOVABLE_PROPERTY_POSITION", SWIG_From_int((int)(1))); 
    }
    {
        PyDict_SetItemString(d,"CEL_MOVE_FAIL", SWIG_From_int((int)(0))); 
    }
    {
        PyDict_SetItemString(d,"CEL_MOVE_SUCCEED", SWIG_From_int((int)(1))); 
    }
    {
        PyDict_SetItemString(d,"CEL_MOVE_PARTIAL", SWIG_From_int((int)(2))); 
    }
    {
        PyDict_SetItemString(d,"CEL_TOOLTIP_LEFT", SWIG_From_int((int)(CEL_TOOLTIP_LEFT))); 
    }
    {
        PyDict_SetItemString(d,"CEL_TOOLTIP_CENTER", SWIG_From_int((int)(CEL_TOOLTIP_CENTER))); 
    }
    {
        PyDict_SetItemString(d,"CEL_TOOLTIP_RIGHT", SWIG_From_int((int)(CEL_TOOLTIP_RIGHT))); 
    }
    {
        PyDict_SetItemString(d,"CEL_DATA_NONE", SWIG_From_int((int)(CEL_DATA_NONE))); 
    }
    {
        PyDict_SetItemString(d,"CEL_DATA_BOOL", SWIG_From_int((int)(CEL_DATA_BOOL))); 
    }
    {
        PyDict_SetItemString(d,"CEL_DATA_BYTE", SWIG_From_int((int)(CEL_DATA_BYTE))); 
    }
    {
        PyDict_SetItemString(d,"CEL_DATA_WORD", SWIG_From_int((int)(CEL_DATA_WORD))); 
    }
    {
        PyDict_SetItemString(d,"CEL_DATA_LONG", SWIG_From_int((int)(CEL_DATA_LONG))); 
    }
    {
        PyDict_SetItemString(d,"CEL_DATA_UBYTE", SWIG_From_int((int)(CEL_DATA_UBYTE))); 
    }
    {
        PyDict_SetItemString(d,"CEL_DATA_UWORD", SWIG_From_int((int)(CEL_DATA_UWORD))); 
    }
    {
        PyDict_SetItemString(d,"CEL_DATA_ULONG", SWIG_From_int((int)(CEL_DATA_ULONG))); 
    }
    {
        PyDict_SetItemString(d,"CEL_DATA_FLOAT", SWIG_From_int((int)(CEL_DATA_FLOAT))); 
    }
    {
        PyDict_SetItemString(d,"CEL_DATA_VECTOR2", SWIG_From_int((int)(CEL_DATA_VECTOR2))); 
    }
    {
        PyDict_SetItemString(d,"CEL_DATA_VECTOR3", SWIG_From_int((int)(CEL_DATA_VECTOR3))); 
    }
    {
        PyDict_SetItemString(d,"CEL_DATA_STRING", SWIG_From_int((int)(CEL_DATA_STRING))); 
    }
    {
        PyDict_SetItemString(d,"CEL_DATA_PCLASS", SWIG_From_int((int)(CEL_DATA_PCLASS))); 
    }
    {
        PyDict_SetItemString(d,"CEL_DATA_ENTITY", SWIG_From_int((int)(CEL_DATA_ENTITY))); 
    }
    {
        PyDict_SetItemString(d,"CEL_DATA_ACTION", SWIG_From_int((int)(CEL_DATA_ACTION))); 
    }
    {
        PyDict_SetItemString(d,"CEL_DATA_COLOR", SWIG_From_int((int)(CEL_DATA_COLOR))); 
    }
    {
        PyDict_SetItemString(d,"CEL_DATA_IBASE", SWIG_From_int((int)(CEL_DATA_IBASE))); 
    }
}

