/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 2.0.4
 * 
 * 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 SWIGRUBY
#define SWIG_DIRECTORS


#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigMovePointer {
    T *ptr;
    SwigMovePointer(T *p) : ptr(p) { }
    ~SwigMovePointer() { delete ptr; }
    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  operator T&() const { return *pointer.ptr; }
  T *operator&() { return pointer.ptr; }
};

template <typename T> T SwigValueInit() {
  return T();
}
#endif

/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

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

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__)) 
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__)) 
# else
#   define SWIGUNUSED 
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif 
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#  ifndef GCC_HASCLASSVISIBILITY
#    define GCC_HASCLASSVISIBILITY
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif 
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif


/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

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

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__)) 
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__)) 
# else
#   define SWIGUNUSED 
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif 
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#  ifndef GCC_HASCLASSVISIBILITY
#    define GCC_HASCLASSVISIBILITY
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif 
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif


/* -----------------------------------------------------------------------------
 * swigrun.swg
 *
 * This file contains generic C API 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 "4"

/* 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

/*
  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 strictly necessary, ie, if you have problems
  with your compiler or suchlike.
*/

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

/*  Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif

/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN        0x1
#define SWIG_CAST_NEW_MEMORY       0x2

/* Flags for new pointer objects */
#define SWIG_POINTER_OWN           0x1


/* 
   Flags/methods for returning states.
   
   The SWIG conversion methods, as ConvertPtr, return an integer 
   that tells if the conversion was successful or not. And if not,
   an error code can be returned (see swigerrors.swg for the codes).
   
   Use the following macros/flags to set or process the returning
   states.
   
   In old versions of SWIG, code such as the following was usually written:

     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
       // success code
     } else {
       //fail code
     }

   Now you can be more explicit:

    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
    } else {
      // fail code
    }

   which is the same really, but now you can also do

    Type *ptr;
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
      if (SWIG_IsNewObj(res) {
        ...
	delete *ptr;
      } else {
        ...
      }
    } else {
      // fail code
    }
    
   I.e., now SWIG_ConvertPtr can return new objects and you can
   identify the case and take care of the deallocation. Of course that
   also requires SWIG_ConvertPtr to return new result values, such as

      int SWIG_ConvertPtr(obj, ptr,...) {         
        if (<obj is ok>) {			       
          if (<need new object>) {		       
            *ptr = <ptr to new allocated object>; 
            return SWIG_NEWOBJ;		       
          } else {				       
            *ptr = <ptr to old object>;	       
            return SWIG_OLDOBJ;		       
          } 				       
        } else {				       
          return SWIG_BADOBJ;		       
        }					       
      }

   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
   SWIG errors code.

   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
   allows to return the 'cast rank', for example, if you have this

       int food(double)
       int fooi(int);

   and you call
 
      food(1)   // cast rank '1'  (1 -> 1.0)
      fooi(1)   // cast rank '0'

   just use the SWIG_AddCast()/SWIG_CheckState()
*/

#define SWIG_OK                    (0) 
#define SWIG_ERROR                 (-1)
#define SWIG_IsOK(r)               (r >= 0)
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)  

/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT         (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
/* The TmpMask is for in/out typemaps that use temporal objects */
#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ                (SWIG_ERROR)
#define SWIG_OLDOBJ                (SWIG_OK)
#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del mask methods */
#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))

/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
#  ifndef SWIG_TypeRank
#    define SWIG_TypeRank             unsigned long
#  endif
#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
#    define SWIG_MAXCASTRANK          (2)
#  endif
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) { 
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) { 
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
}
#else /* no cast-rank mode */
#  define SWIG_AddCast
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

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

/* Structure to store information on one type */
typedef struct swig_type_info {
  const char             *name;			/* mangled name of this type */
  const char             *str;			/* human readable name of this type */
  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
  void                   *clientdata;		/* language specific type data */
  int                    owndata;		/* flag if the structure owns the clientdata */
} swig_type_info;

/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
  swig_converter_func     converter;		/* function to cast the void pointers */
  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
  struct swig_cast_info  *prev;			/* pointer to the previous cast */
} swig_cast_info;

/* Structure used to store module information
 * Each module generates one structure like this, and the runtime collects
 * all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
  size_t                 size;		        /* Number of types in this module */
  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
  swig_type_info         **type_initial;	/* Array of initially generated type structures */
  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
  void                    *clientdata;		/* Language specific module data */
} swig_module_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) ? 1 : -1;
  }
  return (int)((l1 - f1) - (l2 - f2));
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if not equal, 1 if equal
*/
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) ? 1 : 0;
    if (*ne) ++ne;
  }
  return equiv;
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCompare(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) ? 1 : 0;
    if (*ne) ++ne;
  }
  return equiv;
}


/*
  Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (strcmp(iter->type->name, c) == 0) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/* 
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (iter->type == from) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

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

/* 
   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) return NULL;
  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;
}

/* 
   Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_cast_info *cast = ti->cast;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;
  
  while (cast) {
    if (!cast->converter) {
      swig_type_info *tc = cast->type;
      if (!tc->clientdata) {
	SWIG_TypeClientData(tc, clientdata);
      }
    }    
    cast = cast->next;
  }
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
  SWIG_TypeClientData(ti, clientdata);
  ti->owndata = 1;
}
  
/*
  Search for a swig_type_info structure only by mangled name
  Search is a O(log #types)
  
  We start searching at module start, and finish searching when start == end.  
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start, 
                            swig_module_info *end, 
		            const char *name) {
  swig_module_info *iter = start;
  do {
    if (iter->size) {
      register size_t l = 0;
      register size_t r = iter->size - 1;
      do {
	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
	register size_t i = (l + r) >> 1; 
	const char *iname = iter->types[i]->name;
	if (iname) {
	  register int compare = strcmp(name, iname);
	  if (compare == 0) {	    
	    return iter->types[i];
	  } else if (compare < 0) {
	    if (i) {
	      r = i - 1;
	    } else {
	      break;
	    }
	  } else if (compare > 0) {
	    l = i + 1;
	  }
	} else {
	  break; /* should never happen */
	}
      } while (l <= r);
    }
    iter = iter->next;
  } while (iter != end);
  return 0;
}

/*
  Search for a swig_type_info structure for either a mangled name or a human readable name.
  It first searches the mangled names of the types, which is a O(log #types)
  If a type is not found it then searches the human readable names, which is O(#types).
  
  We start searching at module start, and finish searching when start == end.  
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start, 
                     swig_module_info *end, 
		     const char *name) {
  /* STEP 1: Search the name field using binary search */
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
  if (ret) {
    return ret;
  } else {
    /* STEP 2: If the type hasn't been found, do a complete search
       of the str field (the human readable name) */
    swig_module_info *iter = start;
    do {
      register size_t i = 0;
      for (; i < iter->size; ++i) {
	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
	  return iter->types[i];
      }
      iter = iter->next;
    } while (iter != end);
  }
  
  /* neither found a match */
  return 0;
}

/* 
   Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
  static const char hex[17] = "0123456789abcdef";
  register const unsigned char *u = (unsigned char *) ptr;
  register const unsigned char *eu =  u + sz;
  for (; u != eu; ++u) {
    register unsigned char 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 char d = *(c++);
    register unsigned char uu;
    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;
}

/* 
   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

/*  Errors in SWIG */
#define  SWIG_UnknownError    	   -1 
#define  SWIG_IOError        	   -2 
#define  SWIG_RuntimeError   	   -3 
#define  SWIG_IndexError     	   -4 
#define  SWIG_TypeError      	   -5 
#define  SWIG_DivisionByZero 	   -6 
#define  SWIG_OverflowError  	   -7 
#define  SWIG_SyntaxError    	   -8 
#define  SWIG_ValueError     	   -9 
#define  SWIG_SystemError    	   -10
#define  SWIG_AttributeError 	   -11
#define  SWIG_MemoryError    	   -12 
#define  SWIG_NullReferenceError   -13



#include <ruby.h>

/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
 * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
 * issue for now by disabling this.
 * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
 */
#ifdef rb_intern
# undef rb_intern
#endif

/* Remove global macros defined in Ruby's win32.h */
#ifdef write
# undef write
#endif
#ifdef read
# undef read
#endif
#ifdef bind
# undef bind
#endif
#ifdef close
# undef close
#endif
#ifdef connect
# undef connect
#endif


/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
#ifndef NUM2LL
#define NUM2LL(x) NUM2LONG((x))
#endif
#ifndef LL2NUM
#define LL2NUM(x) INT2NUM((long) (x))
#endif
#ifndef ULL2NUM
#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
#endif

/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
#ifndef NUM2ULL
#ifdef HAVE_LONG_LONG
#define NUM2ULL(x) rb_num2ull((x))
#else
#define NUM2ULL(x) NUM2ULONG(x)
#endif
#endif

/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
/* Define these for older versions so we can just write code the new way */
#ifndef RSTRING_LEN
# define RSTRING_LEN(x) RSTRING(x)->len
#endif
#ifndef RSTRING_PTR
# define RSTRING_PTR(x) RSTRING(x)->ptr
#endif
#ifndef RSTRING_END
# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
#endif
#ifndef RARRAY_LEN
# define RARRAY_LEN(x) RARRAY(x)->len
#endif
#ifndef RARRAY_PTR
# define RARRAY_PTR(x) RARRAY(x)->ptr
#endif
#ifndef RFLOAT_VALUE
# define RFLOAT_VALUE(x) RFLOAT(x)->value
#endif
#ifndef DOUBLE2NUM
# define DOUBLE2NUM(x) rb_float_new(x)
#endif
#ifndef RHASH_TBL
# define RHASH_TBL(x) (RHASH(x)->tbl)
#endif
#ifndef RHASH_ITER_LEV
# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
#endif
#ifndef RHASH_IFNONE
# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
#endif
#ifndef RHASH_SIZE
# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
#endif
#ifndef RHASH_EMPTY_P
# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
#endif
#ifndef RSTRUCT_LEN
# define RSTRUCT_LEN(x) RSTRUCT(x)->len
#endif
#ifndef RSTRUCT_PTR
# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
#endif



/*
 * Need to be very careful about how these macros are defined, especially
 * when compiling C++ code or C code with an ANSI C compiler.
 *
 * VALUEFUNC(f) is a macro used to typecast a C function that implements
 * a Ruby method so that it can be passed as an argument to API functions
 * like rb_define_method() and rb_define_singleton_method().
 *
 * VOIDFUNC(f) is a macro used to typecast a C function that implements
 * either the "mark" or "free" stuff for a Ruby Data object, so that it
 * can be passed as an argument to API functions like Data_Wrap_Struct()
 * and Data_Make_Struct().
 */
 
#ifdef __cplusplus
#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
#    define PROTECTFUNC(f) ((VALUE (*)()) f)
#    define VALUEFUNC(f) ((VALUE (*)()) f)
#    define VOIDFUNC(f)  ((void (*)()) f)
#  else
#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
#      define PROTECTFUNC(f) ((VALUE (*)()) f)
#      define VALUEFUNC(f) ((VALUE (*)()) f)
#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
#    else /* These definitions should work for Ruby 1.7+ */
#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
#    endif
#  endif
#else
#  define VALUEFUNC(f) (f)
#  define VOIDFUNC(f) (f)
#endif

/* Don't use for expressions have side effect */
#ifndef RB_STRING_VALUE
#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
#endif
#ifndef StringValue
#define StringValue(s) RB_STRING_VALUE(s)
#endif
#ifndef StringValuePtr
#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
#endif
#ifndef StringValueLen
#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
#endif
#ifndef SafeStringValue
#define SafeStringValue(v) do {\
    StringValue(v);\
    rb_check_safe_str(v);\
} while (0)
#endif

#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
#endif

static VALUE _mSWIG = Qnil;

/* -----------------------------------------------------------------------------
 * error manipulation
 * ----------------------------------------------------------------------------- */


/* Define some additional error types */
#define SWIG_ObjectPreviouslyDeletedError  -100


/* Define custom exceptions for errors that do not map to existing Ruby
   exceptions.  Note this only works for C++ since a global cannot be
   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/

SWIGINTERN VALUE 
getNullReferenceError(void) {
  static int init = 0;
  static VALUE rb_eNullReferenceError ;
  if (!init) {
    init = 1;
    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
  }
  return rb_eNullReferenceError;
} 

SWIGINTERN VALUE 
getObjectPreviouslyDeletedError(void) {
  static int init = 0;
  static VALUE rb_eObjectPreviouslyDeleted ;
  if (!init) {
    init = 1;
    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
  }
  return rb_eObjectPreviouslyDeleted;
} 


SWIGINTERN VALUE
SWIG_Ruby_ErrorType(int SWIG_code) {
  VALUE type;
  switch (SWIG_code) {
  case SWIG_MemoryError:
    type = rb_eNoMemError;
    break;
  case SWIG_IOError:
    type = rb_eIOError;
    break;
  case SWIG_RuntimeError:
    type = rb_eRuntimeError;
    break;
  case SWIG_IndexError:
    type = rb_eIndexError;
    break;
  case SWIG_TypeError:
    type = rb_eTypeError;
    break;
  case SWIG_DivisionByZero:
    type = rb_eZeroDivError;
    break;
  case SWIG_OverflowError:
    type = rb_eRangeError;
    break;
  case SWIG_SyntaxError:
    type = rb_eSyntaxError;
    break;
  case SWIG_ValueError:
    type = rb_eArgError;
    break;
  case SWIG_SystemError:
    type = rb_eFatal;
    break;
  case SWIG_AttributeError:
    type = rb_eRuntimeError;
    break;
  case SWIG_NullReferenceError:
    type = getNullReferenceError();
    break;
  case SWIG_ObjectPreviouslyDeletedError:
    type = getObjectPreviouslyDeletedError();
    break;
  case SWIG_UnknownError:
    type = rb_eRuntimeError;
    break;
  default:
    type = rb_eRuntimeError;
  }
  return type;
}


/* This function is called when a user inputs a wrong argument to
   a method.
 */
SWIGINTERN 
const char* Ruby_Format_TypeError( const char* msg,
				   const char* type, 
				   const char* name, 
				   const int argn,
				   VALUE input )
{
  char buf[128];
  VALUE str;
  VALUE asStr;
  if ( msg && *msg )
    {
      str = rb_str_new2(msg);
    }
  else
    {
      str = rb_str_new(NULL, 0);
    }

  str = rb_str_cat2( str, "Expected argument " );
  sprintf( buf, "%d of type ", argn-1 );
  str = rb_str_cat2( str, buf );
  str = rb_str_cat2( str, type );
  str = rb_str_cat2( str, ", but got " );
  str = rb_str_cat2( str, rb_obj_classname(input) );
  str = rb_str_cat2( str, " " );
  asStr = rb_inspect(input);
  if ( RSTRING_LEN(asStr) > 30 )
    {
      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
      str = rb_str_cat2( str, "..." );
    }
  else
    {
      str = rb_str_append( str, asStr );
    }

  if ( name )
    {
      str = rb_str_cat2( str, "\n\tin SWIG method '" );
      str = rb_str_cat2( str, name );
      str = rb_str_cat2( str, "'" );
    }

  return StringValuePtr( str );
}

/* This function is called when an overloaded method fails */
SWIGINTERN 
void Ruby_Format_OverloadedError(
				 const int argc,
				 const int maxargs,
				 const char* method, 
				 const char* prototypes 
				 )
{
  const char* msg = "Wrong # of arguments";
  if ( argc <= maxargs ) msg = "Wrong arguments";
  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
	   "Possible C/C++ prototypes are:\n%s",
	   msg, method, prototypes);
}

/* -----------------------------------------------------------------------------
 * rubytracking.swg
 *
 * This file contains support for tracking mappings from 
 * Ruby objects to C++ objects.  This functionality is needed
 * to implement mark functions for Ruby's mark and sweep
 * garbage collector.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#endif

/* Ruby 1.8 actually assumes the first case. */
#if SIZEOF_VOIDP == SIZEOF_LONG
#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
#else
#  error sizeof(void*) is not the same as long or long long
#endif


/* Global Ruby hash table to store Trackings from C/C++
   structs to Ruby Objects. 
*/
static VALUE swig_ruby_trackings = Qnil;

/* Global variable that stores a reference to the ruby
   hash table delete function. */
static ID swig_ruby_hash_delete;

/* Setup a Ruby hash table to store Trackings */
SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
  /* Create a ruby hash table to store Trackings from C++ 
     objects to Ruby objects. */

  /* Try to see if some other .so has already created a 
     tracking hash table, which we keep hidden in an instance var
     in the SWIG module.
     This is done to allow multiple DSOs to share the same
     tracking table.
  */
  ID trackings_id = rb_intern( "@__trackings__" );
  VALUE verbose = rb_gv_get("VERBOSE");
  rb_gv_set("VERBOSE", Qfalse);
  swig_ruby_trackings = rb_ivar_get( _mSWIG, trackings_id );
  rb_gv_set("VERBOSE", verbose);

  /* No, it hasn't.  Create one ourselves */ 
  if ( swig_ruby_trackings == Qnil )
    {
      swig_ruby_trackings = rb_hash_new();
      rb_ivar_set( _mSWIG, trackings_id, swig_ruby_trackings );
    }

  /* Now store a reference to the hash table delete function
     so that we only have to look it up once.*/
  swig_ruby_hash_delete = rb_intern("delete");
}

/* Get a Ruby number to reference a pointer */
SWIGRUNTIME VALUE SWIG_RubyPtrToReference(void* ptr) {
  /* We cast the pointer to an unsigned long
     and then store a reference to it using
     a Ruby number object. */

  /* Convert the pointer to a Ruby number */
  return SWIG2NUM(ptr);
}

/* Get a Ruby number to reference an object */
SWIGRUNTIME VALUE SWIG_RubyObjectToReference(VALUE object) {
  /* We cast the object to an unsigned long
     and then store a reference to it using
     a Ruby number object. */

  /* Convert the Object to a Ruby number */
  return SWIG2NUM(object);
}

/* Get a Ruby object from a previously stored reference */
SWIGRUNTIME VALUE SWIG_RubyReferenceToObject(VALUE reference) {
  /* The provided Ruby number object is a reference
     to the Ruby object we want.*/

  /* Convert the Ruby number to a Ruby object */
  return NUM2SWIG(reference);
}

/* Add a Tracking from a C/C++ struct to a Ruby object */
SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
  /* In a Ruby hash table we store the pointer and
     the associated Ruby object.  The trick here is
     that we cannot store the Ruby object directly - if
     we do then it cannot be garbage collected.  So
     instead we typecast it as a unsigned long and
     convert it to a Ruby number object.*/

  /* Get a reference to the pointer as a Ruby number */
  VALUE key = SWIG_RubyPtrToReference(ptr);

  /* Get a reference to the Ruby object as a Ruby number */
  VALUE value = SWIG_RubyObjectToReference(object);

  /* Store the mapping to the global hash table. */
  rb_hash_aset(swig_ruby_trackings, key, value);
}

/* Get the Ruby object that owns the specified C/C++ struct */
SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
  /* Get a reference to the pointer as a Ruby number */
  VALUE key = SWIG_RubyPtrToReference(ptr);

  /* Now lookup the value stored in the global hash table */
  VALUE value = rb_hash_aref(swig_ruby_trackings, key);
	
  if (value == Qnil) {
    /* No object exists - return nil. */
    return Qnil;
  }
  else {
    /* Convert this value to Ruby object */
    return SWIG_RubyReferenceToObject(value);
  }
}

/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
   is very important to remove objects once they are destroyed
   since the same memory address may be reused later to create
   a new object. */
SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
  /* Get a reference to the pointer as a Ruby number */
  VALUE key = SWIG_RubyPtrToReference(ptr);

  /* Delete the object from the hash table by calling Ruby's
     do this we need to call the Hash.delete method.*/
  rb_funcall(swig_ruby_trackings, swig_ruby_hash_delete, 1, key);
}

/* This is a helper method that unlinks a Ruby object from its
   underlying C++ object.  This is needed if the lifetime of the
   Ruby object is longer than the C++ object */
SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
  VALUE object = SWIG_RubyInstanceFor(ptr);

  if (object != Qnil) {
    DATA_PTR(object) = 0;
  }
}


#ifdef __cplusplus
}
#endif

/* -----------------------------------------------------------------------------
 * Ruby API portion that goes into the runtime
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#endif

SWIGINTERN VALUE
SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
  if (NIL_P(target)) {
    target = o;
  } else {
    if (TYPE(target) != T_ARRAY) {
      VALUE o2 = target;
      target = rb_ary_new();
      rb_ary_push(target, o2);
    }
    rb_ary_push(target, o);
  }
  return target;
}

/* For ruby1.8.4 and earlier. */
#ifndef RUBY_INIT_STACK
   RUBY_EXTERN void Init_stack(VALUE* addr);
#  define RUBY_INIT_STACK \
   VALUE variable_in_this_stack_frame; \
   Init_stack(&variable_in_this_stack_frame);
#endif


#ifdef __cplusplus
}
#endif


/* -----------------------------------------------------------------------------
 * rubyrun.swg
 *
 * This file contains the runtime support for Ruby modules
 * and includes code for managing global variables and pointer
 * type checking.
 * ----------------------------------------------------------------------------- */

/* For backward compatibility only */
#define SWIG_POINTER_EXCEPTION  0

/* for raw pointers */
#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
#define swig_owntype                                    ruby_owntype

/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)

/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)

/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)

/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)


/* Runtime API */

#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule()	
#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)


/* Error manipulation */

#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
#define SWIG_fail                        		goto fail				 


/* Ruby-specific SWIG API */

#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  

#include "assert.h"

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

#ifdef __cplusplus
extern "C" {
#endif

typedef struct {
  VALUE klass;
  VALUE mImpl;
  void  (*mark)(void *);
  void  (*destroy)(void *);
  int trackObjects;
} swig_class;


/* Global pointer used to keep some internal SWIG stuff */
static VALUE _cSWIG_Pointer = Qnil;
static VALUE swig_runtime_data_type_pointer = Qnil;

/* Global IDs used to keep some internal SWIG stuff */
static ID swig_arity_id = 0;
static ID swig_call_id  = 0;

/*
  If your swig extension is to be run within an embedded ruby and has
  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
  This will reset ruby's stack frame on each entry point from the main 
  program the first time a virtual director function is invoked (in a 
  non-recursive way).
  If this is not done, you run the risk of Ruby trashing the stack.
*/

#ifdef RUBY_EMBEDDED

#  define SWIG_INIT_STACK                            \
      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
      ++swig_virtual_calls;
#  define SWIG_RELEASE_STACK --swig_virtual_calls;
#  define Ruby_DirectorTypeMismatchException(x) \
          rb_raise( rb_eTypeError, "%s", x ); return c_result;

      static unsigned int swig_virtual_calls = 0;

#else  /* normal non-embedded extension */

#  define SWIG_INIT_STACK
#  define SWIG_RELEASE_STACK
#  define Ruby_DirectorTypeMismatchException(x) \
          throw Swig::DirectorTypeMismatchException( x );

#endif  /* RUBY_EMBEDDED */


SWIGRUNTIME VALUE 
getExceptionClass(void) {
  static int init = 0;
  static VALUE rubyExceptionClass ;
  if (!init) {
    init = 1;
    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
  }
  return rubyExceptionClass;
} 

/* This code checks to see if the Ruby object being raised as part
   of an exception inherits from the Ruby class Exception.  If so,
   the object is simply returned.  If not, then a new Ruby exception
   object is created and that will be returned to Ruby.*/
SWIGRUNTIME VALUE
SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
  VALUE exceptionClass = getExceptionClass();
  if (rb_obj_is_kind_of(obj, exceptionClass)) {
    return obj;
  }  else {
    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
  }
}

/* Initialize Ruby runtime support */
SWIGRUNTIME void
SWIG_Ruby_InitRuntime(void)
{
  if (_mSWIG == Qnil) {
    _mSWIG = rb_define_module("SWIG");
    swig_call_id  = rb_intern("call");
    swig_arity_id = rb_intern("arity");
  }
}

/* Define Ruby class for C type */
SWIGRUNTIME void
SWIG_Ruby_define_class(swig_type_info *type)
{
  VALUE klass;
  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
  sprintf(klass_name, "TYPE%s", type->name);
  if (NIL_P(_cSWIG_Pointer)) {
    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
  }
  klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
  free((void *) klass_name);
}

/* Create a new pointer object */
SWIGRUNTIME VALUE
SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
{
  int own =  flags & SWIG_POINTER_OWN; 
  int track;
  char *klass_name;
  swig_class *sklass;
  VALUE klass;
  VALUE obj;
  
  if (!ptr)
    return Qnil;
  
  if (type->clientdata) {
    sklass = (swig_class *) type->clientdata;
		
    /* Are we tracking this class and have we already returned this Ruby object? */
    track = sklass->trackObjects;
    if (track) {
      obj = SWIG_RubyInstanceFor(ptr);
      
      /* Check the object's type and make sure it has the correct type.
        It might not in cases where methods do things like 
        downcast methods. */
      if (obj != Qnil) {
        VALUE value = rb_iv_get(obj, "@__swigtype__");
        char* type_name = RSTRING_PTR(value);
				
        if (strcmp(type->name, type_name) == 0) {
          return obj;
        }
      }
    }

    /* Create a new Ruby object */
    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
			   ( own ? VOIDFUNC(sklass->destroy) : 
			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
			     ), ptr);

    /* If tracking is on for this class then track this object. */
    if (track) {
      SWIG_RubyAddTracking(ptr, obj);
    }
  } else {
    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
    sprintf(klass_name, "TYPE%s", type->name);
    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
    free((void *) klass_name);
    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
  }
  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
  
  return obj;
}

/* Create a new class instance (always owned) */
SWIGRUNTIME VALUE
SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
{
  VALUE obj;
  swig_class *sklass = (swig_class *) type->clientdata;
  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
  return obj;
}

/* Get type mangle from class name */
SWIGRUNTIMEINLINE char *
SWIG_Ruby_MangleStr(VALUE obj)
{
  VALUE stype = rb_iv_get(obj, "@__swigtype__");
  return StringValuePtr(stype);
}

/* Acquire a pointer value */
typedef void (*ruby_owntype)(void*);

SWIGRUNTIME ruby_owntype
SWIG_Ruby_AcquirePtr(VALUE obj, ruby_owntype own) {
  if (obj) {
    ruby_owntype oldown = RDATA(obj)->dfree;
    RDATA(obj)->dfree = own;
    return oldown;
  } else {
    return 0;
  }
}

/* Convert a pointer value */
SWIGRUNTIME int
SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, ruby_owntype *own)
{
  char *c;
  swig_cast_info *tc;
  void *vptr = 0;

  /* Grab the pointer */
  if (NIL_P(obj)) {
    *ptr = 0;
    return SWIG_OK;
  } else {
    if (TYPE(obj) != T_DATA) {
      return SWIG_ERROR;
    }
    Data_Get_Struct(obj, void, vptr);
  }
  
  if (own) *own = RDATA(obj)->dfree;
    
  /* Check to see if the input object is giving up ownership
     of the underlying C struct or C++ object.  If so then we
     need to reset the destructor since the Ruby object no 
     longer owns the underlying C++ object.*/ 
  if (flags & SWIG_POINTER_DISOWN) {
    /* Is tracking on for this class? */
    int track = 0;
    if (ty && ty->clientdata) {
      swig_class *sklass = (swig_class *) ty->clientdata;
      track = sklass->trackObjects;
    }
		
    if (track) {
      /* We are tracking objects for this class.  Thus we change the destructor
       * to SWIG_RubyRemoveTracking.  This allows us to
       * remove the mapping from the C++ to Ruby object
       * when the Ruby object is garbage collected.  If we don't
       * do this, then it is possible we will return a reference 
       * to a Ruby object that no longer exists thereby crashing Ruby. */
      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
    } else {    
      RDATA(obj)->dfree = 0;
    }
  }

  /* Do type-checking if type info was provided */
  if (ty) {
    if (ty->clientdata) {
      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
        if (vptr == 0) {
          /* The object has already been deleted */
          return SWIG_ObjectPreviouslyDeletedError;
        }
        *ptr = vptr;
        return SWIG_OK;
      }
    }
    if ((c = SWIG_MangleStr(obj)) == NULL) {
      return SWIG_ERROR;
    }
    tc = SWIG_TypeCheck(c, ty);
    if (!tc) {
      return SWIG_ERROR;
    } else {
      int newmemory = 0;
      *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
      assert(!newmemory); /* newmemory handling not yet implemented */
    }
  } else {
    *ptr = vptr;
  }
  
  return SWIG_OK;
}

/* Check convert */
SWIGRUNTIMEINLINE int
SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
{
  char *c = SWIG_MangleStr(obj);
  if (!c) return 0;
  return SWIG_TypeCheck(c,ty) != 0;
}

SWIGRUNTIME VALUE
SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
  char result[1024];
  char *r = result;
  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r, ptr, sz);
  strcpy(r, type->name);
  return rb_str_new2(result);
}

/* Convert a packed value value */
SWIGRUNTIME int
SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
  swig_cast_info *tc;
  const char  *c;

  if (TYPE(obj) != T_STRING) goto type_error;
  c = StringValuePtr(obj);
  /* Pointer values must start with leading underscore */
  if (*c != '_') goto type_error;
  c++;
  c = SWIG_UnpackData(c, ptr, sz);
  if (ty) {
    tc = SWIG_TypeCheck(c, ty);
    if (!tc) goto type_error;
  }
  return SWIG_OK;

 type_error:
  return SWIG_ERROR;
}

SWIGRUNTIME swig_module_info *
SWIG_Ruby_GetModule(void)
{
  VALUE pointer;
  swig_module_info *ret = 0;
  VALUE verbose = rb_gv_get("VERBOSE");

 /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
  rb_gv_set("VERBOSE", Qfalse);
  
  /* first check if pointer already created */
  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
  if (pointer != Qnil) {
    Data_Get_Struct(pointer, swig_module_info, ret);
  }

  /* reinstate warnings */
  rb_gv_set("VERBOSE", verbose);
  return ret;
}

SWIGRUNTIME void 
SWIG_Ruby_SetModule(swig_module_info *pointer)
{
  /* register a new class */
  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
  /* create and store the structure pointer to a global variable */
  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
}

/* This function can be used to check whether a proc or method or similarly
   callable function has been passed.  Usually used in a %typecheck, like:

   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
        $result = SWIG_Ruby_isCallable( $input );
   }
 */
SWIGINTERN
int SWIG_Ruby_isCallable( VALUE proc )
{
  if ( rb_respond_to( proc, swig_call_id ) == Qtrue )
    return 1;
  return 0;
}

/* This function can be used to check the arity (number of arguments)
   a proc or method can take.  Usually used in a %typecheck.
   Valid arities will be that equal to minimal or those < 0
   which indicate a variable number of parameters at the end.
 */
SWIGINTERN
int SWIG_Ruby_arity( VALUE proc, int minimal )
{
  if ( rb_respond_to( proc, swig_arity_id ) == Qtrue )
    {
      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
      int arity = NUM2INT(num);
      if ( arity < 0 && (arity+1) < -minimal ) return 1;
      if ( arity == minimal ) return 1;
      return 1;
    }
  return 0;
}


#ifdef __cplusplus
}
#endif



#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 

#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 


/* -----------------------------------------------------------------------------
 * director.swg
 *
 * This file contains support for director classes that proxy
 * method calls from C++ to Ruby extensions.
 * ----------------------------------------------------------------------------- */

/*
  Use -DSWIG_DIRECTOR_NOUEH if you prefer to avoid the use of the
  Undefined Exception Handler provided by swift
*/
#ifndef SWIG_DIRECTOR_NOUEH
#ifndef SWIG_DIRECTOR_UEH
#define SWIG_DIRECTOR_UEH
#endif
#endif

#ifdef __cplusplus

#include <string>
#include <iostream>
#include <map>

# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG)

namespace Swig {
  /* memory handler */
  struct GCItem 
  {
    virtual ~GCItem()
    {
    }

    virtual ruby_owntype get_own() const
    {
      return 0;
    }
  };
  
  struct GCItem_var
  {
    GCItem_var(GCItem *item = 0) : _item(item)
    {
    }

    GCItem_var& operator=(GCItem *item)
    {
      GCItem *tmp = _item;
      _item = item;
      delete tmp;
      return *this;
    }
    
    ~GCItem_var() 
    {
      delete _item;
    }
    
    GCItem * operator->() const
    {
      return _item;
    }
    
  private:
    GCItem *_item;
  };


  template <typename Type>
  struct GCItem_T : GCItem
  {
    GCItem_T(Type *ptr) : _ptr(ptr)
    {
    }
    
    virtual ~GCItem_T() 
    {
      delete _ptr;
    }
    
  private:
    Type *_ptr;
  };

  struct GCItem_Object : GCItem
  {
    GCItem_Object(ruby_owntype own) : _own(own)
    {
    }
    
    virtual ~GCItem_Object() 
    {
    }

    ruby_owntype get_own() const
    {
      return _own;
    }
    
  private:
    ruby_owntype _own;
  };


  template <typename Type>
  struct GCArray_T : GCItem
  {
    GCArray_T(Type *ptr) : _ptr(ptr)
    {
    }
    
    virtual ~GCArray_T() 
    {
      delete[] _ptr;
    }
    
  private:
    Type *_ptr;
  };


  /* body args */
  struct body_args {
    VALUE recv;
    ID id;
    int argc;
    VALUE *argv;
  };
  
  /* Base class for director exceptions */
  class DirectorException {
  protected:
    VALUE swig_error;
    std::string swig_msg;
  protected:
    DirectorException(VALUE error)
      : swig_error(error)
    {
    }
    
    DirectorException(VALUE error, const char* hdr, const char* msg ="") 
      : swig_error(error), swig_msg(hdr) {
      if (strlen(msg)) {
	swig_msg += " ";
	swig_msg += msg;
      }
      if (swig_msg.size()) {
	VALUE str = rb_str_new(swig_msg.data(), swig_msg.size());
	swig_error = rb_exc_new3(error, str);
      } else {
	swig_error = error;
      }
    }
  public:
    VALUE getType() const  { 
      return CLASS_OF(swig_error); 
    }
    VALUE getError() const {
      return swig_error;
    }
    const std::string& getMessage() const 
    {
      return swig_msg;
    }
    
    virtual ~DirectorException() {}
  };
  
  /* unknown exception handler  */

  class UnknownExceptionHandler 
  {
#ifdef SWIG_DIRECTOR_UEH
    static void handler() {
      try {
	throw;
      } catch (DirectorException& e) {
	std::cerr << "SWIG Director exception caught:" << std::endl
		  << e.getMessage() << std::endl;
      } catch (std::exception& e) {
	std::cerr << "std::exception caught: "<< e.what() << std::endl;
      } catch (...) {
	std::cerr << "Unknown exception caught." << std::endl;
      }      
      std::cerr << std::endl
		<< "Ruby interpreter traceback:" << std::endl;
      std::cerr << std::endl;      
      std::cerr << "This exception was caught by the SWIG unexpected exception handler." << std::endl
		<< "Try using %feature(\"director:except\") to avoid reaching this point." << std::endl
		<< std::endl
		<< "Exception is being re-thrown, program will like abort/terminate." << std::endl;
      throw;
    }
    
  public:    
    std::unexpected_handler old;
    UnknownExceptionHandler(std::unexpected_handler nh = handler)
    {
      old = std::set_unexpected(nh);
    }

    ~UnknownExceptionHandler()
    {
      std::set_unexpected(old);
    }
#endif
  };


  /* Type mismatch in the return value from a Ruby method call */
  class DirectorTypeMismatchException : public Swig::DirectorException {
  public:
    DirectorTypeMismatchException(VALUE error, const char *msg="")
      : Swig::DirectorException(error, "SWIG director type mismatch", msg) 
    {
    }

    DirectorTypeMismatchException(const char *msg="")
      : Swig::DirectorException(rb_eTypeError, "SWIG director type mismatch", msg) 
    {
    }

    static void raise(VALUE error, const char *msg) {
      throw DirectorTypeMismatchException(error, msg);
    }

    static void raise(const char *msg) {
      throw DirectorTypeMismatchException(msg);
    }
  };

  /* Any Ruby exception that occurs during a director method call */
  class DirectorMethodException : public Swig::DirectorException {
  public:
    DirectorMethodException(VALUE error) 
      : Swig::DirectorException(error) {
    }

    DirectorMethodException(const char* msg = "") 
      : Swig::DirectorException(rb_eRuntimeError, "SWIG director method error.", msg) {
    }
    
    static void raise(VALUE error)
    {
      throw DirectorMethodException(error);
    }    
  };

  /* Attempted to call a pure virtual method via a director method */
  class DirectorPureVirtualException : public Swig::DirectorException
  {
  public:
    DirectorPureVirtualException(const char* msg = "") 
      : DirectorException(rb_eRuntimeError, "SWIG director pure virtual method called", msg)
    { 
    }

    static void raise(const char *msg) 
    {
      throw DirectorPureVirtualException(msg);
    }
  };

  /* Simple thread abstraction for pthreads on win32 */
#ifdef __THREAD__
# define __PTHREAD__
# if defined(_WIN32) || defined(__WIN32__)
#  define pthread_mutex_lock EnterCriticalSection
#  define pthread_mutex_unlock LeaveCriticalSection
#  define pthread_mutex_t CRITICAL_SECTION
#  define SWIG_MUTEX_INIT(var) var
# else
#  include <pthread.h>
#  define SWIG_MUTEX_INIT(var) var = PTHREAD_MUTEX_INITIALIZER 
# endif
#endif

#ifdef  __PTHREAD__
  struct Guard
  {
    pthread_mutex_t *_mutex;
    
    Guard(pthread_mutex_t &mutex) : _mutex(&mutex)
    {
      pthread_mutex_lock(_mutex);
    }
    
    ~Guard()
    {
      pthread_mutex_unlock(_mutex);
    }
  };
# define SWIG_GUARD(mutex) Guard _guard(mutex)
#else
# define SWIG_GUARD(mutex) 
#endif

  /* director base class */
  class Director {
  private:
    /* pointer to the wrapped Ruby object */
    VALUE swig_self;
    /* flag indicating whether the object is owned by Ruby or c++ */
    mutable bool swig_disown_flag;

  public:
    /* wrap a Ruby object, optionally taking ownership */
    Director(VALUE self) : swig_self(self), swig_disown_flag(false) {
    }

    /* discard our reference at destruction */
    virtual ~Director() {
    }

    /* return a pointer to the wrapped Ruby object */
    VALUE swig_get_self() const { 
      return swig_self; 
    }

    /* acquire ownership of the wrapped Ruby object (the sense of "disown"
     * is from Ruby) */
    void swig_disown() const { 
      if (!swig_disown_flag) { 
        swig_disown_flag = true;
      } 
    }

  /* ownership management */
  private:
    typedef std::map<void*, GCItem_var> swig_ownership_map;
    mutable swig_ownership_map swig_owner;
#ifdef __PTHREAD__
    static pthread_mutex_t swig_mutex_own;
#endif

  public:
    template <typename Type>
    void swig_acquire_ownership_array(Type *vptr)  const
    {
      if (vptr) {
	SWIG_GUARD(swig_mutex_own);
	swig_owner[vptr] = new GCArray_T<Type>(vptr);
      }
    }
    
    template <typename Type>
    void swig_acquire_ownership(Type *vptr)  const
    {
      if (vptr) {	
	SWIG_GUARD(swig_mutex_own);
	swig_owner[vptr] = new GCItem_T<Type>(vptr);
      }
    }

    void swig_acquire_ownership_obj(void *vptr, ruby_owntype own) const
    {
      if (vptr && own) {
	SWIG_GUARD(swig_mutex_own);
	swig_owner[vptr] = new GCItem_Object(own);
      }
    }
    
    ruby_owntype swig_release_ownership(void *vptr) const
    {
      ruby_owntype own = 0;
      if (vptr) {
	SWIG_GUARD(swig_mutex_own);
	swig_ownership_map::iterator iter = swig_owner.find(vptr);
	if (iter != swig_owner.end()) {
	  own = iter->second->get_own();
	  swig_owner.erase(iter);
	}
      }
      return own;
    }
  };
}

#endif /* __cplusplus */



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

#define SWIGTYPE_p_AliasTextureIterator swig_types[0]
#define SWIGTYPE_p_AnimationIterator swig_types[1]
#define SWIGTYPE_p_ArchiveMapIterator swig_types[2]
#define SWIGTYPE_p_AutoConstantIterator swig_types[3]
#define SWIGTYPE_p_AutoConstantList swig_types[4]
#define SWIGTYPE_p_BatchInstanceIterator swig_types[5]
#define SWIGTYPE_p_BatchInstanceMap swig_types[6]
#define SWIGTYPE_p_BindingIndexMap swig_types[7]
#define SWIGTYPE_p_BoneAssignmentIterator swig_types[8]
#define SWIGTYPE_p_BoneBlendMask swig_types[9]
#define SWIGTYPE_p_BoneHandleMap swig_types[10]
#define SWIGTYPE_p_BoneIterator swig_types[11]
#define SWIGTYPE_p_BoneList swig_types[12]
#define SWIGTYPE_p_BoundSufaceList swig_types[13]
#define SWIGTYPE_p_Box swig_types[14]
#define SWIGTYPE_p_CameraIterator swig_types[15]
#define SWIGTYPE_p_CameraList swig_types[16]
#define SWIGTYPE_p_ChildContainerIterator swig_types[17]
#define SWIGTYPE_p_ChildContainerMap swig_types[18]
#define SWIGTYPE_p_ChildIterator swig_types[19]
#define SWIGTYPE_p_ChildMap swig_types[20]
#define SWIGTYPE_p_ChildNodeIterator swig_types[21]
#define SWIGTYPE_p_ChildNodeMap swig_types[22]
#define SWIGTYPE_p_ChildObjectList swig_types[23]
#define SWIGTYPE_p_ChildObjectListIterator swig_types[24]
#define SWIGTYPE_p_CodePoint swig_types[25]
#define SWIGTYPE_p_CodePointRange swig_types[26]
#define SWIGTYPE_p_CodePointRangeList swig_types[27]
#define SWIGTYPE_p_CodecDataPtr swig_types[28]
#define SWIGTYPE_p_CodecIterator swig_types[29]
#define SWIGTYPE_p_CompiledState swig_types[30]
#define SWIGTYPE_p_ConstChildNodeIterator swig_types[31]
#define SWIGTYPE_p_ConstNormalsIterator swig_types[32]
#define SWIGTYPE_p_ConstObjectIterator swig_types[33]
#define SWIGTYPE_p_ConstPoseIterator swig_types[34]
#define SWIGTYPE_p_ConstPoseRefIterator swig_types[35]
#define SWIGTYPE_p_ConstPriorityMapIterator swig_types[36]
#define SWIGTYPE_p_ConstQueueGroupIterator swig_types[37]
#define SWIGTYPE_p_ConstTerrainIterator swig_types[38]
#define SWIGTYPE_p_ConstTextureUnitStateIterator swig_types[39]
#define SWIGTYPE_p_ConstVertexOffsetIterator swig_types[40]
#define SWIGTYPE_p_ContentCollectionFactoryMap swig_types[41]
#define SWIGTYPE_p_ContentCollectionList swig_types[42]
#define SWIGTYPE_p_ContentFactoryMap swig_types[43]
#define SWIGTYPE_p_ContentList swig_types[44]
#define SWIGTYPE_p_CornerEnum swig_types[45]
#define SWIGTYPE_p_DecodeResult swig_types[46]
#define SWIGTYPE_p_Edge swig_types[47]
#define SWIGTYPE_p_EdgeGroupList swig_types[48]
#define SWIGTYPE_p_EdgeList swig_types[49]
#define SWIGTYPE_p_EdgeMap swig_types[50]
#define SWIGTYPE_p_EffectMap swig_types[51]
#define SWIGTYPE_p_ElementList swig_types[52]
#define SWIGTYPE_p_ElementMap swig_types[53]
#define SWIGTYPE_p_EntitySet swig_types[54]
#define SWIGTYPE_p_ErrorList swig_types[55]
#define SWIGTYPE_p_ErrorPtr swig_types[56]
#define SWIGTYPE_p_FactoryMap swig_types[57]
#define SWIGTYPE_p_GPUDeviceNameRuleIterator swig_types[58]
#define SWIGTYPE_p_GPUDeviceNameRuleList swig_types[59]
#define SWIGTYPE_p_GPUVendorRuleIterator swig_types[60]
#define SWIGTYPE_p_GPUVendorRuleList swig_types[61]
#define SWIGTYPE_p_GpuSharedParamUsageList swig_types[62]
#define SWIGTYPE_p_HardwareAnimationDataList swig_types[63]
#define SWIGTYPE_p_IdMap swig_types[64]
#define SWIGTYPE_p_IlluminationPassIterator swig_types[65]
#define SWIGTYPE_p_IndexMap swig_types[66]
#define SWIGTYPE_p_IndexRemapList swig_types[67]
#define SWIGTYPE_p_InstanceBatchIterator swig_types[68]
#define SWIGTYPE_p_InstanceBatchMapIterator swig_types[69]
#define SWIGTYPE_p_InstanceIterator swig_types[70]
#define SWIGTYPE_p_InstancedEntityVec swig_types[71]
#define SWIGTYPE_p_Instances swig_types[72]
#define SWIGTYPE_p_Intp swig_types[73]
#define SWIGTYPE_p_LODFaceList swig_types[74]
#define SWIGTYPE_p_LayerInstanceList swig_types[75]
#define SWIGTYPE_p_LinkedSkeletonAnimSourceIterator swig_types[76]
#define SWIGTYPE_p_LinkedSkeletonAnimSourceList swig_types[77]
#define SWIGTYPE_p_LocationList swig_types[78]
#define SWIGTYPE_p_LodLevelList swig_types[79]
#define SWIGTYPE_p_LodValueIterator swig_types[80]
#define SWIGTYPE_p_LodValueList swig_types[81]
#define SWIGTYPE_p_MeshLodUsageList swig_types[82]
#define SWIGTYPE_p_MetaDataIterator swig_types[83]
#define SWIGTYPE_p_MetaDataList swig_types[84]
#define SWIGTYPE_p_Microcode swig_types[85]
#define SWIGTYPE_p_MicrocodeMap swig_types[86]
#define SWIGTYPE_p_MovableObjectFactoryIterator swig_types[87]
#define SWIGTYPE_p_MovableObjectIterator swig_types[88]
#define SWIGTYPE_p_NodeIterator swig_types[89]
#define SWIGTYPE_p_NodeList swig_types[90]
#define SWIGTYPE_p_NodeTrackIterator swig_types[91]
#define SWIGTYPE_p_NodeTrackList swig_types[92]
#define SWIGTYPE_p_NormalsIterator swig_types[93]
#define SWIGTYPE_p_NormalsMap swig_types[94]
#define SWIGTYPE_p_NumericTrackIterator swig_types[95]
#define SWIGTYPE_p_NumericTrackList swig_types[96]
#define SWIGTYPE_p_ObjectIterator swig_types[97]
#define SWIGTYPE_p_ObjectMap swig_types[98]
#define SWIGTYPE_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_ANIMATION_t_t swig_types[99]
#define SWIGTYPE_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GENERAL_t_t swig_types[100]
#define SWIGTYPE_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_t_t swig_types[101]
#define SWIGTYPE_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RENDERSYS_t_t swig_types[102]
#define SWIGTYPE_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RESOURCE_t_t swig_types[103]
#define SWIGTYPE_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_CONTROL_t_t swig_types[104]
#define SWIGTYPE_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_OBJECTS_t_t swig_types[105]
#define SWIGTYPE_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCRIPTING_t_t swig_types[106]
#define SWIGTYPE_p_Ogre__AnimationStateIterator swig_types[107]
#define SWIGTYPE_p_Ogre__AxisAlignedBox swig_types[108]
#define SWIGTYPE_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_ANIMATION_t swig_types[109]
#define SWIGTYPE_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GENERAL_t swig_types[110]
#define SWIGTYPE_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_t swig_types[111]
#define SWIGTYPE_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RENDERSYS_t swig_types[112]
#define SWIGTYPE_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RESOURCE_t swig_types[113]
#define SWIGTYPE_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_CONTROL_t swig_types[114]
#define SWIGTYPE_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_OBJECTS_t swig_types[115]
#define SWIGTYPE_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCRIPTING_t swig_types[116]
#define SWIGTYPE_p_Ogre__ConstAnimationStateIterator swig_types[117]
#define SWIGTYPE_p_Ogre__ConstEnabledAnimationStateIterator swig_types[118]
#define SWIGTYPE_p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__GpuConstantDefinition_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuConstantDefinition_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[119]
#define SWIGTYPE_p_Ogre__ConstShadowTextureConfigIterator swig_types[120]
#define SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t swig_types[121]
#define SWIGTYPE_p_Ogre__ManualObject swig_types[122]
#define SWIGTYPE_p_Ogre__Matrix4 swig_types[123]
#define SWIGTYPE_p_Ogre__MeshPtr swig_types[124]
#define SWIGTYPE_p_Ogre__MovablePlane swig_types[125]
#define SWIGTYPE_p_Ogre__Plane swig_types[126]
#define SWIGTYPE_p_Ogre__Quaternion swig_types[127]
#define SWIGTYPE_p_Ogre__Radian swig_types[128]
#define SWIGTYPE_p_Ogre__Rectangle swig_types[129]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AbstractNode_t swig_types[130]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t swig_types[131]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ConcreteNode_t swig_types[132]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ControllerFunctionT_float_t_t swig_types[133]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ControllerValueT_float_t_t swig_types[134]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t swig_types[135]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuLogicalBufferStruct_t swig_types[136]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuNamedConstants_t swig_types[137]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t swig_types[138]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuSharedParameters_t swig_types[139]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__MemoryDataStream_t swig_types[140]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__RenderToVertexBuffer_t swig_types[141]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t swig_types[142]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ScriptToken_t swig_types[143]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ShadowCameraSetup_t swig_types[144]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__TerrainMaterialGenerator_t swig_types[145]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[146]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[147]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__DataStreamPtr_Ogre__STLAllocatorT_Ogre__DataStreamPtr_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[148]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[149]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__ScriptTokenPtr_Ogre__STLAllocatorT_Ogre__ScriptTokenPtr_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[150]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[151]
#define SWIGTYPE_p_Ogre__SimpleSpline swig_types[152]
#define SWIGTYPE_p_Ogre__TRectT_float_t swig_types[153]
#define SWIGTYPE_p_Ogre__TRectT_long_t swig_types[154]
#define SWIGTYPE_p_Ogre__UTFString swig_types[155]
#define SWIGTYPE_p_Ogre__Vector2 swig_types[156]
#define SWIGTYPE_p_Ogre__Vector3 swig_types[157]
#define SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__RenderQueueInvocation_p_Ogre__STLAllocatorT_Ogre__RenderQueueInvocation_p_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[158]
#define SWIGTYPE_p_Ogre__VertexBoneAssignment_s swig_types[159]
#define SWIGTYPE_p_Ogre___ConfigOption swig_types[160]
#define SWIGTYPE_p_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type swig_types[161]
#define SWIGTYPE_p_Ogre__listT_Ogre__AnimationState_p_Ogre__STLAllocatorT_Ogre__AnimationState_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[162]
#define SWIGTYPE_p_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type swig_types[163]
#define SWIGTYPE_p_Ogre__listT_Ogre__DataStreamPtr_Ogre__STLAllocatorT_Ogre__DataStreamPtr_Ogre__GeneralAllocPolicy_t_t__type swig_types[164]
#define SWIGTYPE_p_Ogre__listT_Ogre__MovableObject_p_Ogre__STLAllocatorT_Ogre__MovableObject_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[165]
#define SWIGTYPE_p_Ogre__listT_Ogre__SceneQueryMovableObjectPair_Ogre__STLAllocatorT_Ogre__SceneQueryMovableObjectPair_Ogre__GeneralAllocPolicy_t_t__type swig_types[166]
#define SWIGTYPE_p_Ogre__listT_Ogre__SceneQueryMovableObjectWorldFragmentPair_Ogre__STLAllocatorT_Ogre__SceneQueryMovableObjectWorldFragmentPair_Ogre__GeneralAllocPolicy_t_t__type swig_types[167]
#define SWIGTYPE_p_Ogre__listT_Ogre__WorldFragment_p_Ogre__STLAllocatorT_Ogre__WorldFragment_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[168]
#define SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__AnimationState_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__AnimationState_p_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[169]
#define SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__ConfigOption_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ConfigOption_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[170]
#define SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__GpuConstantDefinition_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuConstantDefinition_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[171]
#define SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__ParamCommand_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParamCommand_p_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[172]
#define SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__ParamDictionary_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParamDictionary_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[173]
#define SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__RenderTarget_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__RenderTarget_p_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[174]
#define SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[175]
#define SWIGTYPE_p_Ogre__mapT_Ogre__String_bool_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_bool_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[176]
#define SWIGTYPE_p_Ogre__mapT_Ogre__uint16_Ogre__DepthBufferVec_std__lessT_Ogre__uint16_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint16_const_Ogre__DepthBufferVec_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[177]
#define SWIGTYPE_p_Ogre__mapT_size_t_Ogre__GpuLogicalIndexUse_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__GpuLogicalIndexUse_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[178]
#define SWIGTYPE_p_Ogre__multimapT_Ogre__uchar_Ogre__RenderTarget_p_std__lessT_Ogre__uchar_t_Ogre__STLAllocatorT_std__pairT_Ogre__uchar_const_Ogre__RenderTarget_p_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[179]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__DepthBuffer_p_Ogre__STLAllocatorT_Ogre__DepthBuffer_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[180]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type swig_types[181]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__HardwareBuffer__Usage_Ogre__STLAllocatorT_Ogre__HardwareBuffer__Usage_Ogre__GeneralAllocPolicy_t_t__type swig_types[182]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__IlluminationPass_p_Ogre__STLAllocatorT_Ogre__IlluminationPass_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[183]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__Image_const_p_Ogre__STLAllocatorT_Ogre__Image_const_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[184]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__Image_p_Ogre__STLAllocatorT_Ogre__Image_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[185]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__ParameterDef_Ogre__STLAllocatorT_Ogre__ParameterDef_Ogre__GeneralAllocPolicy_t_t__type swig_types[186]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__PixelFormat_Ogre__STLAllocatorT_Ogre__PixelFormat_Ogre__GeneralAllocPolicy_t_t__type swig_types[187]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__PlaneBoundedVolume_Ogre__STLAllocatorT_Ogre__PlaneBoundedVolume_Ogre__GeneralAllocPolicy_t_t__type swig_types[188]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type swig_types[189]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__Pose_p_Ogre__STLAllocatorT_Ogre__Pose_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[190]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__RaySceneQueryResultEntry_Ogre__STLAllocatorT_Ogre__RaySceneQueryResultEntry_Ogre__GeneralAllocPolicy_t_t__type swig_types[191]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__RenderQueueInvocation_p_Ogre__STLAllocatorT_Ogre__RenderQueueInvocation_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[192]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__RenderSystem_p_Ogre__STLAllocatorT_Ogre__RenderSystem_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[193]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__RenderWindowDescription_Ogre__STLAllocatorT_Ogre__RenderWindowDescription_Ogre__GeneralAllocPolicy_t_t__type swig_types[194]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__RenderWindow_p_Ogre__STLAllocatorT_Ogre__RenderWindow_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[195]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__ScriptTokenPtr_Ogre__STLAllocatorT_Ogre__ScriptTokenPtr_Ogre__GeneralAllocPolicy_t_t__type swig_types[196]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__ShadowTextureConfig_Ogre__STLAllocatorT_Ogre__ShadowTextureConfig_Ogre__GeneralAllocPolicy_t_t__type swig_types[197]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type swig_types[198]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__TerrainLayerBlendMap_p_Ogre__STLAllocatorT_Ogre__TerrainLayerBlendMap_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[199]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__TerrainLayerSamplerElement_Ogre__STLAllocatorT_Ogre__TerrainLayerSamplerElement_Ogre__GeneralAllocPolicy_t_t__type swig_types[200]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__TerrainLayerSampler_Ogre__STLAllocatorT_Ogre__TerrainLayerSampler_Ogre__GeneralAllocPolicy_t_t__type swig_types[201]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__TexturePtr_Ogre__STLAllocatorT_Ogre__TexturePtr_Ogre__GeneralAllocPolicy_t_t__type swig_types[202]
#define SWIGTYPE_p_Ogre__vectorT_float_Ogre__STLAllocatorT_float_Ogre__GeneralAllocPolicy_t_t__type swig_types[203]
#define SWIGTYPE_p_Ogre__vectorT_int_Ogre__STLAllocatorT_int_Ogre__GeneralAllocPolicy_t_t__type swig_types[204]
#define SWIGTYPE_p_OptimalAdjustFactorList swig_types[205]
#define SWIGTYPE_p_OptimisedSubMeshGeometryList swig_types[206]
#define SWIGTYPE_p_Overlay2DElementsIterator swig_types[207]
#define SWIGTYPE_p_OverlayContainerList swig_types[208]
#define SWIGTYPE_p_OverlayMap swig_types[209]
#define SWIGTYPE_p_OverlayMapIterator swig_types[210]
#define SWIGTYPE_p_PageMap swig_types[211]
#define SWIGTYPE_p_ParticleAffectorFactoryIterator swig_types[212]
#define SWIGTYPE_p_ParticleAffectorFactoryMap swig_types[213]
#define SWIGTYPE_p_ParticleEmitterFactoryIterator swig_types[214]
#define SWIGTYPE_p_ParticleEmitterFactoryMap swig_types[215]
#define SWIGTYPE_p_ParticleRendererFactoryIterator swig_types[216]
#define SWIGTYPE_p_ParticleSystemRendererFactoryMap swig_types[217]
#define SWIGTYPE_p_ParticleSystemTemplateIterator swig_types[218]
#define SWIGTYPE_p_ParticleTemplateMap swig_types[219]
#define SWIGTYPE_p_PassIterator swig_types[220]
#define SWIGTYPE_p_PassSet swig_types[221]
#define SWIGTYPE_p_Passes swig_types[222]
#define SWIGTYPE_p_PlaneList swig_types[223]
#define SWIGTYPE_p_PluginInstanceList swig_types[224]
#define SWIGTYPE_p_PluginLibList swig_types[225]
#define SWIGTYPE_p_PolygonList swig_types[226]
#define SWIGTYPE_p_PoseIterator swig_types[227]
#define SWIGTYPE_p_PoseRefIterator swig_types[228]
#define SWIGTYPE_p_PoseRefList swig_types[229]
#define SWIGTYPE_p_PriorityMap swig_types[230]
#define SWIGTYPE_p_PriorityMapIterator swig_types[231]
#define SWIGTYPE_p_Procedural__BoxGenerator swig_types[232]
#define SWIGTYPE_p_Procedural__CapsuleGenerator swig_types[233]
#define SWIGTYPE_p_Procedural__CatmullRomSpline2 swig_types[234]
#define SWIGTYPE_p_Procedural__CatmullRomSpline3 swig_types[235]
#define SWIGTYPE_p_Procedural__Circle swig_types[236]
#define SWIGTYPE_p_Procedural__CircleShape swig_types[237]
#define SWIGTYPE_p_Procedural__ConeGenerator swig_types[238]
#define SWIGTYPE_p_Procedural__CubicHermiteSpline2 swig_types[239]
#define SWIGTYPE_p_Procedural__CubicHermiteSpline3 swig_types[240]
#define SWIGTYPE_p_Procedural__CylinderGenerator swig_types[241]
#define SWIGTYPE_p_Procedural__Extruder swig_types[242]
#define SWIGTYPE_p_Procedural__IcoSphereGenerator swig_types[243]
#define SWIGTYPE_p_Procedural__KochanekBartelsSpline2 swig_types[244]
#define SWIGTYPE_p_Procedural__Lathe swig_types[245]
#define SWIGTYPE_p_Procedural__Line swig_types[246]
#define SWIGTYPE_p_Procedural__Line2D swig_types[247]
#define SWIGTYPE_p_Procedural__LinePath swig_types[248]
#define SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t swig_types[249]
#define SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t swig_types[250]
#define SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t swig_types[251]
#define SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t swig_types[252]
#define SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t swig_types[253]
#define SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t swig_types[254]
#define SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t swig_types[255]
#define SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t swig_types[256]
#define SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t swig_types[257]
#define SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t swig_types[258]
#define SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t swig_types[259]
#define SWIGTYPE_p_Procedural__MultiShape swig_types[260]
#define SWIGTYPE_p_Procedural__Path swig_types[261]
#define SWIGTYPE_p_Procedural__Plane swig_types[262]
#define SWIGTYPE_p_Procedural__PlaneGenerator swig_types[263]
#define SWIGTYPE_p_Procedural__RectangleShape swig_types[264]
#define SWIGTYPE_p_Procedural__Root swig_types[265]
#define SWIGTYPE_p_Procedural__RoundedBoxGenerator swig_types[266]
#define SWIGTYPE_p_Procedural__RoundedCornerSpline2 swig_types[267]
#define SWIGTYPE_p_Procedural__RoundedCornerSpline3 swig_types[268]
#define SWIGTYPE_p_Procedural__Segment2D swig_types[269]
#define SWIGTYPE_p_Procedural__Shape swig_types[270]
#define SWIGTYPE_p_Procedural__SphereGenerator swig_types[271]
#define SWIGTYPE_p_Procedural__TorusGenerator swig_types[272]
#define SWIGTYPE_p_Procedural__TorusKnotGenerator swig_types[273]
#define SWIGTYPE_p_Procedural__Track swig_types[274]
#define SWIGTYPE_p_Procedural__TriangleBuffer swig_types[275]
#define SWIGTYPE_p_Procedural__Triangulator swig_types[276]
#define SWIGTYPE_p_Procedural__TubeGenerator swig_types[277]
#define SWIGTYPE_p_Procedural__Utils swig_types[278]
#define SWIGTYPE_p_ProfileList swig_types[279]
#define SWIGTYPE_p_QuadMaterialMap swig_types[280]
#define SWIGTYPE_p_QueueGroupIterator swig_types[281]
#define SWIGTYPE_p_QueuedGeometryList swig_types[282]
#define SWIGTYPE_p_QueuedSubMeshList swig_types[283]
#define SWIGTYPE_p_QueuedSubMeshOriginList swig_types[284]
#define SWIGTYPE_p_RealVector swig_types[285]
#define SWIGTYPE_p_Rect swig_types[286]
#define SWIGTYPE_p_RegionIterator swig_types[287]
#define SWIGTYPE_p_RegionMap swig_types[288]
#define SWIGTYPE_p_RenderOperationVector swig_types[289]
#define SWIGTYPE_p_RenderSystemOpPair swig_types[290]
#define SWIGTYPE_p_RenderSystemOpPairs swig_types[291]
#define SWIGTYPE_p_RenderTargetIterator swig_types[292]
#define SWIGTYPE_p_RequestID swig_types[293]
#define SWIGTYPE_p_ResourceCreateOrRetrieveResult swig_types[294]
#define SWIGTYPE_p_ResourceDeclarationList swig_types[295]
#define SWIGTYPE_p_ResourceHandleMap swig_types[296]
#define SWIGTYPE_p_ResourceManagerIterator swig_types[297]
#define SWIGTYPE_p_ResourceManagerMap swig_types[298]
#define SWIGTYPE_p_ResourceMap swig_types[299]
#define SWIGTYPE_p_ResourceMapIterator swig_types[300]
#define SWIGTYPE_p_ResourceWithGroupMap swig_types[301]
#define SWIGTYPE_p_SceneManagerIterator swig_types[302]
#define SWIGTYPE_p_SchemeHardwareAnimMap swig_types[303]
#define SWIGTYPE_p_SectionIterator swig_types[304]
#define SWIGTYPE_p_SectionList swig_types[305]
#define SWIGTYPE_p_SectionMap swig_types[306]
#define SWIGTYPE_p_SettingsBySection swig_types[307]
#define SWIGTYPE_p_SettingsIterator swig_types[308]
#define SWIGTYPE_p_SettingsMultiMap swig_types[309]
#define SWIGTYPE_p_ShaderProfiles swig_types[310]
#define SWIGTYPE_p_ShadowRenderableList swig_types[311]
#define SWIGTYPE_p_ShadowRenderableListIterator swig_types[312]
#define SWIGTYPE_p_SharedParametersMap swig_types[313]
#define SWIGTYPE_p_SplitPointList swig_types[314]
#define SWIGTYPE_p_StrStreamType swig_types[315]
#define SWIGTYPE_p_StrategyMap swig_types[316]
#define SWIGTYPE_p_SubMeshGeometryLookup swig_types[317]
#define SWIGTYPE_p_SubMeshIterator swig_types[318]
#define SWIGTYPE_p_SubMeshList swig_types[319]
#define SWIGTYPE_p_SubMeshLodGeometryLinkList swig_types[320]
#define SWIGTYPE_p_SubMeshNameMap swig_types[321]
#define SWIGTYPE_p_SyntaxCodes swig_types[322]
#define SWIGTYPE_p_TargetPassIterator swig_types[323]
#define SWIGTYPE_p_TargetPasses swig_types[324]
#define SWIGTYPE_p_TechniqueIterator swig_types[325]
#define SWIGTYPE_p_Techniques swig_types[326]
#define SWIGTYPE_p_TemplateIterator swig_types[327]
#define SWIGTYPE_p_TerrainIterator swig_types[328]
#define SWIGTYPE_p_TerrainList swig_types[329]
#define SWIGTYPE_p_TerrainSlotMap swig_types[330]
#define SWIGTYPE_p_TextureDefinitionIterator swig_types[331]
#define SWIGTYPE_p_TextureDefinitions swig_types[332]
#define SWIGTYPE_p_TextureUnitStateIterator swig_types[333]
#define SWIGTYPE_p_TrackHandleList swig_types[334]
#define SWIGTYPE_p_TriangleFaceNormalList swig_types[335]
#define SWIGTYPE_p_TriangleLightFacingList swig_types[336]
#define SWIGTYPE_p_TriangleList swig_types[337]
#define SWIGTYPE_p_UVRect swig_types[338]
#define SWIGTYPE_p_UniqueTextureSet swig_types[339]
#define SWIGTYPE_p_VertexBoneAssignmentList swig_types[340]
#define SWIGTYPE_p_VertexBufferBindingMap swig_types[341]
#define SWIGTYPE_p_VertexElementList swig_types[342]
#define SWIGTYPE_p_VertexList swig_types[343]
#define SWIGTYPE_p_VertexOffsetIterator swig_types[344]
#define SWIGTYPE_p_VertexOffsetMap swig_types[345]
#define SWIGTYPE_p_VertexSplit swig_types[346]
#define SWIGTYPE_p_VertexSplits swig_types[347]
#define SWIGTYPE_p_VertexTrackIterator swig_types[348]
#define SWIGTYPE_p_VertexTrackList swig_types[349]
#define SWIGTYPE_p_WindowEventListeners swig_types[350]
#define SWIGTYPE_p_Windows swig_types[351]
#define SWIGTYPE_p_WorldMap swig_types[352]
#define SWIGTYPE_p_WorldSectionFactoryMap swig_types[353]
#define SWIGTYPE_p__zzip_plugin_io swig_types[354]
#define SWIGTYPE_p_char swig_types[355]
#define SWIGTYPE_p_code_point swig_types[356]
#define SWIGTYPE_p_const_iterator swig_types[357]
#define SWIGTYPE_p_const_reverse_iterator swig_types[358]
#define SWIGTYPE_p_dstring swig_types[359]
#define SWIGTYPE_p_float swig_types[360]
#define SWIGTYPE_p_int swig_types[361]
#define SWIGTYPE_p_iterator swig_types[362]
#define SWIGTYPE_p_long_long swig_types[363]
#define SWIGTYPE_p_reverse_iterator swig_types[364]
#define SWIGTYPE_p_short swig_types[365]
#define SWIGTYPE_p_size_type swig_types[366]
#define SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[367]
#define SWIGTYPE_p_std__mapT_Ogre__Real_Ogre__Real_std__lessT_Ogre__Real_t_std__allocatorT_std__pairT_Ogre__Real_const_Ogre__Real_t_t_t__const_iterator swig_types[368]
#define SWIGTYPE_p_std__pairT_Ogre__MovableObject_p_Ogre__MovableObject_p_t swig_types[369]
#define SWIGTYPE_p_std__pairT_Ogre__MovableObject_p_Ogre__WorldFragment_p_t swig_types[370]
#define SWIGTYPE_p_std__string swig_types[371]
#define SWIGTYPE_p_std__vectorT_Ogre__Vector2_std__allocatorT_Ogre__Vector2_t_t swig_types[372]
#define SWIGTYPE_p_std__vectorT_Ogre__Vector3_std__allocatorT_Ogre__Vector3_t_t swig_types[373]
#define SWIGTYPE_p_std__vectorT_Vertex_std__allocatorT_Vertex_t_t swig_types[374]
#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[375]
#define SWIGTYPE_p_stdext__hash_compareT_Ogre___StringBase_std__lessT_Ogre___StringBase_t_t swig_types[376]
#define SWIGTYPE_p_unicode_char swig_types[377]
#define SWIGTYPE_p_unsigned_char swig_types[378]
#define SWIGTYPE_p_unsigned_int swig_types[379]
#define SWIGTYPE_p_unsigned_long swig_types[380]
#define SWIGTYPE_p_unsigned_long_long swig_types[381]
#define SWIGTYPE_p_unsigned_short swig_types[382]
#define SWIGTYPE_p_utf32string swig_types[383]
#define SWIGTYPE_p_value_type swig_types[384]
#define SWIGTYPE_p_z_stream_s swig_types[385]
#define SWIGTYPE_p_zzip_dir swig_types[386]
#define SWIGTYPE_p_zzip_file swig_types[387]
static swig_type_info *swig_types[389];
static swig_module_info swig_module = {swig_types, 388, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

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

#define SWIG_init    Init_procedural
#define SWIG_name    "Procedural"

static VALUE mProcedural;

#define SWIG_RUBY_THREAD_BEGIN_BLOCK
#define SWIG_RUBY_THREAD_END_BLOCK


#define SWIGVERSION 0x020004 
#define SWIG_VERSION SWIGVERSION


#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 


#include <stdexcept>


namespace swig {
  class GC_VALUE {
  protected:
    // Hash of all GC_VALUE's currently in use
    static VALUE _hash;

    VALUE  _obj;

    static ID hash_id;
    static ID   lt_id;
    static ID   gt_id;
    static ID   eq_id;
    static ID   le_id;
    static ID   ge_id;

    static ID  pos_id;
    static ID  neg_id;
    static ID  inv_id;

    static ID  add_id;
    static ID  sub_id;
    static ID  mul_id;
    static ID  div_id;
    static ID  mod_id;

    static ID  and_id;
    static ID   or_id;
    static ID  xor_id;

    static ID  lshift_id;
    static ID  rshift_id;

    struct OpArgs
    {
      VALUE src;
      ID    id;
      int   nargs;
      VALUE target;
    };


  public:
    static void initialize()
    {
      if ( _hash == Qnil ) 
	{ 
	  _hash = rb_hash_new();
	  rb_gc_register_address( &_hash );
	}
    }

    // this function is never called.  Provided for symmetry only.
    static void cleanup()
    {
      rb_gc_unregister_address( &_hash );
    }

    GC_VALUE() : _obj( Qnil )
    {
    }

    GC_VALUE(const GC_VALUE& item) : _obj(item._obj)
    {
      GC_register();
    }
    
    GC_VALUE(VALUE obj) :_obj(obj)
    {
      GC_register();
    }
    
    ~GC_VALUE() 
    {
      GC_unregister();
    }
    
    GC_VALUE & operator=(const GC_VALUE& item) 
    {
      GC_unregister();
      _obj = item._obj;
      GC_register();
      return *this;
    }

    void GC_register()
    {
      if ( FIXNUM_P(_obj) || SPECIAL_CONST_P(_obj) || SYMBOL_P(_obj) ) 
	return;
      VALUE val = rb_hash_aref( _hash, _obj );
      unsigned n = FIXNUM_P(val) ? NUM2UINT(val) : 0;
      ++n;
      rb_hash_aset( _hash, _obj, INT2NUM(n) );
    }

    void GC_unregister()
    {
      if ( FIXNUM_P(_obj) || SPECIAL_CONST_P(_obj) || SYMBOL_P(_obj) ) 
	return;
      // this test should not be needed but I've noticed some very erratic
      // behavior of none being unregistered in some very rare situations.
      if ( BUILTIN_TYPE(_obj) == T_NONE ) return;

      VALUE val = rb_hash_aref( _hash, _obj );
      unsigned n = FIXNUM_P(val) ? NUM2UINT(val) : 1;
      --n;
      if ( n )
	rb_hash_aset( _hash, _obj, INT2NUM(n) );
      else
	rb_hash_delete( _hash, _obj );
    }
    
    operator VALUE() const
    {
      return _obj;
    }

    VALUE inspect() const
    {
      return rb_inspect(_obj);
    }

    VALUE to_s() const
    {
      return rb_inspect(_obj);
    }

    static VALUE swig_protect_funcall( VALUE p )
    {
      OpArgs* args = (OpArgs*) p;
      return rb_funcall( args->src, args->id, args->nargs, args->target );
    }


#define GC_VALUE_CMP( op_id, op, cmp, cmpval ) \
    bool op( const GC_VALUE& other ) const \
    { \
      if ( FIXNUM_P(_obj) && FIXNUM_P(other._obj) ) \
      { \
	return _obj cmp other._obj; \
      } \
      bool  res = false; \
      VALUE ret = Qnil; \
      SWIG_RUBY_THREAD_BEGIN_BLOCK; \
      if ( rb_respond_to( _obj, op_id ) == Qtrue ) \
	{ \
	  int status; \
	  OpArgs  args; \
          args.src    = _obj; \
	  args.id     = op_id; \
	  args.nargs  = 1; \
	  args.target = VALUE(other); \
	  ret = rb_protect( PROTECTFUNC(swig_protect_funcall), \
                            VALUE(&args), &status ); \
	} \
      if ( ret == Qnil ) { \
	VALUE a = rb_funcall(         _obj, hash_id, 0 ); \
	VALUE b = rb_funcall( VALUE(other), hash_id, 0 ); \
	res = a cmp b; \
      } \
      else \
	{ \
	  res = RTEST( ret ); \
	} \
      SWIG_RUBY_THREAD_END_BLOCK; \
      return res; \
    }


    GC_VALUE_CMP( eq_id, operator==, ==, == 0 )
    GC_VALUE_CMP( lt_id, operator<,  < , <  0 )
    GC_VALUE_CMP( le_id, operator<=, <=, <= 0 )
    GC_VALUE_CMP( gt_id, operator>,  > , >  0 )
    GC_VALUE_CMP( ge_id, operator>=, >=, >= 0 )
#undef GC_VALUE_CMP

    bool operator!=( const GC_VALUE& other )
    {
      return !(this->operator==(other));
    }

#define GC_VALUE_UNARY( proc_id, op ) \
    GC_VALUE op() const \
    { \
      VALUE ret = Qnil; \
      SWIG_RUBY_THREAD_BEGIN_BLOCK; \
      int status; \
      OpArgs  args; \
      args.src    = _obj; \
      args.id     = proc_id; \
      args.nargs  = 0; \
      args.target = Qnil; \
      ret = rb_protect( PROTECTFUNC(swig_protect_funcall), VALUE(&args), \
			&status ); \
      SWIG_RUBY_THREAD_END_BLOCK; \
      return ret; \
    }

    GC_VALUE_UNARY( pos_id, operator+ )
    GC_VALUE_UNARY( neg_id, operator- )
    GC_VALUE_UNARY( inv_id, operator~ )
#undef GC_VALUE_BINARY

#define GC_VALUE_BINARY( proc_id, op ) \
    GC_VALUE op( const GC_VALUE& other ) const \
    { \
      VALUE ret = Qnil; \
      SWIG_RUBY_THREAD_BEGIN_BLOCK; \
      int status; \
      OpArgs  args; \
      args.src    = _obj; \
      args.id     = proc_id; \
      args.nargs  = 1; \
      args.target = VALUE(other); \
      ret = rb_protect( PROTECTFUNC(swig_protect_funcall), VALUE(&args), \
			&status ); \
      SWIG_RUBY_THREAD_END_BLOCK; \
      return GC_VALUE(ret); \
    }

    GC_VALUE_BINARY( add_id, operator+ );
    GC_VALUE_BINARY( sub_id, operator- );
    GC_VALUE_BINARY( mul_id, operator* );
    GC_VALUE_BINARY( div_id, operator/ );
    GC_VALUE_BINARY( mod_id, operator% );
    
    GC_VALUE_BINARY( and_id, operator& );
    GC_VALUE_BINARY( xor_id, operator^ );
    GC_VALUE_BINARY(  or_id, operator| );

    GC_VALUE_BINARY( lshift_id, operator<< );
    GC_VALUE_BINARY( rshift_id, operator>> );
#undef GC_VALUE_BINARY

  };

  ID  GC_VALUE::hash_id = rb_intern("hash");
  ID  GC_VALUE::lt_id = rb_intern("<");
  ID  GC_VALUE::gt_id = rb_intern(">");
  ID  GC_VALUE::eq_id = rb_intern("==");
  ID  GC_VALUE::le_id = rb_intern("<=");
  ID  GC_VALUE::ge_id = rb_intern(">=");

  ID  GC_VALUE::pos_id = rb_intern("+@");
  ID  GC_VALUE::neg_id = rb_intern("-@");
  ID  GC_VALUE::inv_id = rb_intern("~");

  ID  GC_VALUE::add_id = rb_intern("+");
  ID  GC_VALUE::sub_id = rb_intern("-");
  ID  GC_VALUE::mul_id = rb_intern("*");
  ID  GC_VALUE::div_id = rb_intern("/");
  ID  GC_VALUE::mod_id = rb_intern("%");

  ID  GC_VALUE::and_id = rb_intern("&");
  ID  GC_VALUE::or_id  = rb_intern("|");
  ID  GC_VALUE::xor_id = rb_intern("^");

  ID  GC_VALUE::lshift_id = rb_intern("<<");
  ID  GC_VALUE::rshift_id = rb_intern(">>");

  VALUE GC_VALUE::_hash = Qnil;

  typedef GC_VALUE LANGUAGE_OBJ;

} // namespace swig


  
namespace swig {
  struct stop_iteration {
  };

  /** 
   * Abstract base class used to represent all iterators of STL containers.
   */
  struct ConstIterator {
  public:
    typedef ConstIterator self_type;

  protected:
    GC_VALUE _seq;

  protected:
    ConstIterator(VALUE seq) : _seq(seq)
    {
    }

    // Random access iterator methods, but not required in Ruby
    virtual ptrdiff_t distance(const ConstIterator &x) const
    {
      throw std::invalid_argument("distance not supported");
    }

    virtual bool equal (const ConstIterator &x) const
    {
      throw std::invalid_argument("equal not supported");
    }

    virtual self_type* advance(ptrdiff_t n)
    {
      throw std::invalid_argument("advance not supported");
    }
      
  public:
    virtual ~ConstIterator() {}

    // Access iterator method, required by Ruby
    virtual VALUE value() const {
      throw std::invalid_argument("value not supported");
      return Qnil;
    };

    virtual VALUE setValue( const VALUE& v ) {
      throw std::invalid_argument("value= not supported");
      return Qnil;
    }

    virtual self_type* next( size_t n = 1 )
    {
      return this->advance( n );
    }

    virtual self_type* previous( size_t n = 1 )
    {
      ptrdiff_t nn = n;
      return this->advance( -nn );
    }

    virtual VALUE to_s() const {
      throw std::invalid_argument("to_s not supported");
      return Qnil;
    }

    virtual VALUE inspect() const {
      throw std::invalid_argument("inspect not supported");
      return Qnil;
    }
    
    virtual ConstIterator *dup() const
    {
      throw std::invalid_argument("dup not supported");
      return NULL;
    }

    //
    // C++ common/needed methods.  We emulate a bidirectional
    // operator, to be compatible with all the STL.
    // The iterator traits will then tell the STL what type of
    // iterator we really are.
    //
    ConstIterator() : _seq( Qnil )
    {
    }

    ConstIterator( const self_type& b ) : _seq( b._seq )
    {
    }

    self_type& operator=( const self_type& b )
    {
      _seq = b._seq;
      return *this;
    }

    bool operator == (const ConstIterator& x)  const
    {
      return equal(x);
    }
      
    bool operator != (const ConstIterator& x) const
    {
      return ! operator==(x);
    }
      
    // Pre-decrement operator
    self_type& operator--()
    {
      return *previous();
    }

    // Pre-increment operator
    self_type& operator++()
    {
      return *next();
    }

    // Post-decrement operator
    self_type operator--(int)
    {
      self_type r = *this;
      previous();
      return r;
    }

    // Post-increment operator
    self_type operator++(int)
    {
      self_type r = *this;
      next();
      return r;
    }

    ConstIterator& operator += (ptrdiff_t n)
    {
      return *advance(n);
    }

    ConstIterator& operator -= (ptrdiff_t n)
    {
      return *advance(-n);
    }

    ConstIterator* operator + (ptrdiff_t n) const
    {
      return dup()->advance(n);
    }

    ConstIterator* operator - (ptrdiff_t n) const
    {
      return dup()->advance(-n);
    }
      
    ptrdiff_t operator - (const ConstIterator& x) const
    {
      return x.distance(*this);
    }
      
    static swig_type_info* descriptor() {
      static int init = 0;
      static swig_type_info* desc = 0;
      if (!init) {
	desc = SWIG_TypeQuery("swig::ConstIterator *");
	init = 1;
      }	
      return desc;
    }
  };


  /**
   * Abstract base class used to represent all non-const iterators of STL containers.
   * 
   */
  struct Iterator : public ConstIterator {
  public:
    typedef Iterator self_type;

  protected:
    Iterator(VALUE seq) : ConstIterator(seq)
    {
    }

    virtual self_type* advance(ptrdiff_t n)
    {
      throw std::invalid_argument("operation not supported");
    }

  public:
    static swig_type_info* descriptor() {
      static int init = 0;
      static swig_type_info* desc = 0;
      if (!init) {
	desc = SWIG_TypeQuery("swig::Iterator *");
	init = 1;
      }	
      return desc;
    }
    
    virtual Iterator *dup() const
    {
      throw std::invalid_argument("dup not supported");
      return NULL;
    }
      
    virtual self_type* next( size_t n = 1 )
    {
      return this->advance( n );
    }

    virtual self_type* previous( size_t n = 1 )
    {
      ptrdiff_t nn = n;
      return this->advance( -nn );
    }

    bool operator == (const ConstIterator& x)  const
    {
      return equal(x);
    }
      
    bool operator != (const Iterator& x) const
    {
      return ! operator==(x);
    }
      
    Iterator& operator += (ptrdiff_t n)
    {
      return *advance(n);
    }

    Iterator& operator -= (ptrdiff_t n)
    {
      return *advance(-n);
    }
      
    Iterator* operator + (ptrdiff_t n) const
    {
      return dup()->advance(n);
    }

    Iterator* operator - (ptrdiff_t n) const
    {
      return dup()->advance(-n);
    }
      
    ptrdiff_t operator - (const Iterator& x) const
    {
      return x.distance(*this);
    }
  };

}


typedef int Intp;


#include <ProceduralPlatform.h>


#include <limits.h>
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
#   define LLONG_MAX __LONG_LONG_MAX__
#   define LLONG_MIN (-LLONG_MAX - 1LL)
#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif


  #define SWIG_From_long   LONG2NUM 


SWIGINTERNINLINE VALUE
SWIG_From_int  (int value)
{    
  return SWIG_From_long  (value);
}




#include <Ogre.h>
#include <ProceduralRoot.h>



// hmm... someting wrong about GC.	

static void debug_free_ProcRoot(void* ptr) {
	Procedural::Root* obj = (Procedural::Root*) ptr;
	
	std::cout << __PRETTY_FUNCTION__ << std::endl;
	 
//	 delete obj;
 }


#include <ProceduralUtils.h>


SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
  static int init = 0;
  static swig_type_info* info = 0;
  if (!init) {
    info = SWIG_TypeQuery("_p_char");
    init = 1;
  }
  return info;
}


SWIGINTERN int
SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
{
  if (TYPE(obj) == T_STRING) {
    #if defined(StringValuePtr)
    char *cstr = StringValuePtr(obj); 
    #else
    char *cstr = STR2CSTR(obj);
    #endif
    size_t size = RSTRING_LEN(obj) + 1;
    if (cptr)  {
      if (alloc) {
	if (*alloc == SWIG_NEWOBJ) {
	  *cptr = reinterpret_cast< char* >(memcpy((new char[size]), cstr, sizeof(char)*(size)));
	} else {
	  *cptr = cstr;
	  *alloc = SWIG_OLDOBJ;
	}
      }
    }
    if (psize) *psize = size;
    return SWIG_OK;
  } else {
    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    if (pchar_descriptor) {
      void* vptr = 0;
      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
	if (cptr) *cptr = (char *)vptr;
	if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
	if (alloc) *alloc = SWIG_OLDOBJ;
	return SWIG_OK;
      }
    }
  }  
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsPtr_std_string (VALUE obj, std::string **val) 
{
  char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
  if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
    if (buf) {
      if (val) *val = new std::string(buf, size - 1);
      if (alloc == SWIG_NEWOBJ) delete[] buf;
      return SWIG_NEWOBJ;
    } else {
      if (val) *val = 0;
      return SWIG_OLDOBJ;
    }
  } else {
    static int init = 0;
    static swig_type_info* descriptor = 0;
    if (!init) {
      descriptor = SWIG_TypeQuery("std::string" " *");
      init = 1;
    }
    if (descriptor) {
      std::string *vptr;
      int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
      if (SWIG_IsOK(res) && val) *val = vptr;
      return res;
    }
  }
  return SWIG_ERROR;
}


SWIGINTERNINLINE VALUE 
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
  if (carray) {
    if (size > LONG_MAX) {
      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
      return pchar_descriptor ? 
	SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
    } else {
      return rb_str_new(carray, static_cast< long >(size));
    }
  } else {
    return Qnil;
  }
}


SWIGINTERNINLINE VALUE
SWIG_From_std_string  (const std::string& s)
{
  return SWIG_FromCharPtrAndSize(s.data(), s.size());
}


SWIGINTERN VALUE
SWIG_ruby_failed(void)
{
  return Qnil;
} 


/*@SWIG:/usr/share/swig2.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
{
  VALUE obj = args[0];
  VALUE type = TYPE(obj);
  long *res = (long *)(args[1]);
  *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);
  return obj;
}
/*@SWIG@*/

SWIGINTERN int
SWIG_AsVal_long (VALUE obj, long* val)
{
  VALUE type = TYPE(obj);
  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
    long v;
    VALUE a[2];
    a[0] = obj;
    a[1] = (VALUE)(&v);
    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
      if (val) *val = v;
      return SWIG_OK;
    }
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_int (VALUE obj, int *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < INT_MIN || v > INT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< int >(v);
    }
  }  
  return res;
}




#include <ProceduralTriangleBuffer.h>


#include <float.h>


/*@SWIG:/usr/share/swig2.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE *args)
{
  VALUE obj = args[0];
  VALUE type = TYPE(obj);
  double *res = (double *)(args[1]);
  *res = NUM2DBL(obj);
  return obj;
}
/*@SWIG@*/

SWIGINTERN int
SWIG_AsVal_double (VALUE obj, double *val)
{
  VALUE type = TYPE(obj);
  if ((type == T_FLOAT) || (type == T_FIXNUM) || (type == T_BIGNUM)) {
    double v;
    VALUE a[2];
    a[0] = obj;
    a[1] = (VALUE)(&v);
    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
      if (val) *val = v;
      return SWIG_OK;
    }
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_float (VALUE obj, float *val)
{
  double v;
  int res = SWIG_AsVal_double (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < -FLT_MAX || v > FLT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< float >(v);
    }
  }  
  return res;
}


/*@SWIG:/usr/share/swig2.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
{
  VALUE obj = args[0];
  VALUE type = TYPE(obj);
  unsigned long *res = (unsigned long *)(args[1]);
  *res = type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj);
  return obj;
}
/*@SWIG@*/

SWIGINTERN int
SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val) 
{
  VALUE type = TYPE(obj);
  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
    unsigned long v;
    VALUE a[2];
    a[0] = obj;
    a[1] = (VALUE)(&v);
    if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
      if (val) *val = v;
      return SWIG_OK;
    }
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_int (VALUE obj, unsigned int *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UINT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned int >(v);
    }
  }  
  return res;
}


	typedef Procedural::TriangleBuffer::Vertex Vertex;


#include <ProceduralMeshGenerator.h>




#include <ProceduralBoxGenerator.h>


SWIGINTERN int
SWIG_AsVal_bool (VALUE obj, bool *val)
{
  if (obj == Qtrue) {
    if (val) *val = true;
    return SWIG_OK;
  } else if (obj == Qfalse) {
    if (val) *val = false;
    return SWIG_OK;
  } else {
    int res = 0;
    if (SWIG_AsVal_int (obj, &res) == SWIG_OK) {    
      if (val) *val = res ? true : false;
      return SWIG_OK;
    }
  }  
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_char (VALUE obj, unsigned char *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UCHAR_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned char >(v);
    }
  }  
  return res;
}




#include <ProceduralCapsuleGenerator.h>




#include <ProceduralConeGenerator.h>




#include <ProceduralCylinderGenerator.h>




#include <ProceduralIcoSphereGenerator.h>




#include <ProceduralMultiShape.h>


SWIGINTERNINLINE VALUE
SWIG_From_bool  (bool value)
{
  return value ? Qtrue : Qfalse;
}




#include <ProceduralPlaneGenerator.h>




#include <ProceduralRoundedBoxGenerator.h>


SWIGINTERN int
SWIG_AsVal_unsigned_SS_short (VALUE obj, unsigned short *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > USHRT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned short >(v);
    }
  }  
  return res;
}




#include <ProceduralSphereGenerator.h>




#include <ProceduralTorusGenerator.h>




#include <ProceduralTorusKnotGenerator.h>




#include <ProceduralTubeGenerator.h>




#include <ProceduralTrack.h>


  #define SWIG_From_double   rb_float_new 


SWIGINTERNINLINE VALUE
SWIG_From_float  (float value)
{    
  return SWIG_From_double  (value);
}




#include <ProceduralShape.h>


SWIGINTERNINLINE int
SWIG_AsVal_size_t (VALUE obj, size_t *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
  if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
  return res;
}


SWIGINTERNINLINE VALUE
SWIG_From_unsigned_SS_long  (unsigned long value)
{
  return ULONG2NUM(value); 
}


SWIGINTERNINLINE VALUE
SWIG_From_size_t  (size_t value)
{    
  return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
}




#include <ProceduralSplines.h>




#include <ProceduralShapeGenerators.h>




#include <ProceduralGeometryHelpers.h>




#include <ProceduralLathe.h>




#include <ProceduralPath.h>




#include <ProceduralPathGenerators.h>




#include <ProceduralExtruder.h>




#include <ProceduralStableHeaders.h>




#include <ProceduralTriangulator.h>




#include <Procedural.h>





/* ---------------------------------------------------
 * C++ director class helpers
 * --------------------------------------------------- */



/* ---------------------------------------------------
 * C++ director class methods
 * --------------------------------------------------- */

#include "procedural_wrap.h"

swig_class SwigClassRoot;

SWIGINTERN VALUE
_wrap_Root_get_instance(int argc, VALUE *argv, VALUE self) {
  Procedural::Root *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::Root *)Procedural::Root::getInstance();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Root, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassUtils;

SWIGINTERN VALUE
_wrap_Utils_log(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::String const &","Procedural::Utils::log", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Procedural::Utils::log", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    try {
      Procedural::Utils::log((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Utils_min__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Vector3 result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Procedural::Utils::min", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Procedural::Utils::min", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Procedural::Utils::min", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Procedural::Utils::min", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = Procedural::Utils::min((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Utils_max__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Vector3 result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Procedural::Utils::max", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Procedural::Utils::max", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Procedural::Utils::max", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Procedural::Utils::max", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = Procedural::Utils::max((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Utils_min__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Vector2 result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","Procedural::Utils::min", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","Procedural::Utils::min", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","Procedural::Utils::min", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","Procedural::Utils::min", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  {
    try {
      result = Procedural::Utils::min((Ogre::Vector2 const &)*arg1,(Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Utils_min(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Utils_min__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Utils_min__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Utils.min", 
    "    Ogre::Vector2 Utils.min(Ogre::Vector3 const &v1, Ogre::Vector3 const &v2)\n"
    "    Ogre::Vector2 Utils.min(Ogre::Vector2 const &v1, Ogre::Vector2 const &v2)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Utils_max__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Vector2 result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","Procedural::Utils::max", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","Procedural::Utils::max", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","Procedural::Utils::max", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","Procedural::Utils::max", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  {
    try {
      result = Procedural::Utils::max((Ogre::Vector2 const &)*arg1,(Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Utils_max(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Utils_max__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Utils_max__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Utils.max", 
    "    Ogre::Vector2 Utils.max(Ogre::Vector3 const &v1, Ogre::Vector3 const &v2)\n"
    "    Ogre::Vector2 Utils.max(Ogre::Vector2 const &v1, Ogre::Vector2 const &v2)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Utils_aabbfrom_points(int argc, VALUE *argv, VALUE self) {
  SwigValueWrapper< std::vector< Ogre::Vector3,std::allocator< Ogre::Vector3 > > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_std__vectorT_Ogre__Vector3_std__allocatorT_Ogre__Vector3_t_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< Ogre::Vector3,std::allocator< Ogre::Vector3 > >","Procedural::Utils::AABBfromPoints", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< Ogre::Vector3,std::allocator< Ogre::Vector3 > >","Procedural::Utils::AABBfromPoints", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< std::vector< Ogre::Vector3,std::allocator< Ogre::Vector3 > > * >(argp1));
    }
  }
  {
    try {
      result = Procedural::Utils::AABBfromPoints(arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::AxisAlignedBox(static_cast< const Ogre::AxisAlignedBox& >(result))), SWIGTYPE_p_Ogre__AxisAlignedBox, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Utils_get_name__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::string result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","Procedural::Utils::getName", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","Procedural::Utils::getName", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = Procedural::Utils::getName((std::string const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Utils_get_name__SWIG_1(int argc, VALUE *argv, VALUE self) {
  std::string result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = Procedural::Utils::getName();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Utils_get_name(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_Utils_get_name__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Utils_get_name__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Utils.get_name", 
    "    std::string Utils.get_name(std::string const &prefix)\n"
    "    std::string Utils.get_name()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Utils_vector_permute(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::Vector3 result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Procedural::Utils::vectorPermute", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Procedural::Utils::vectorPermute", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  {
    try {
      result = Procedural::Utils::vectorPermute((Ogre::Vector3 const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Utils_vector_anti_permute(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::Vector3 result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Procedural::Utils::vectorAntiPermute", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Procedural::Utils::vectorAntiPermute", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  {
    try {
      result = Procedural::Utils::vectorAntiPermute((Ogre::Vector3 const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Utils_rotate_vector2(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = 0 ;
  Ogre::Radian arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Vector2 result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","Procedural::Utils::rotateVector2", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","Procedural::Utils::rotateVector2", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Radian,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Radian","Procedural::Utils::rotateVector2", 2, argv[1] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian","Procedural::Utils::rotateVector2", 2, argv[1]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Radian * >(argp2));
    }
  }
  {
    try {
      result = Procedural::Utils::rotateVector2((Ogre::Vector2 const &)*arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Utils_cap(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Procedural::Utils::cap", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Procedural::Utils::cap", 2, argv[1] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Procedural::Utils::cap", 3, argv[2] ));
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (int)Procedural::Utils::cap(arg1,arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Utils_modulo(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Procedural::Utils::modulo", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Procedural::Utils::modulo", 2, argv[1] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (int)Procedural::Utils::modulo(arg1,arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Utils_angle_between(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Radian result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","Procedural::Utils::angleBetween", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","Procedural::Utils::angleBetween", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","Procedural::Utils::angleBetween", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","Procedural::Utils::angleBetween", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  {
    try {
      result = Procedural::Utils::angleBetween((Ogre::Vector2 const &)*arg1,(Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Utils_angle_to(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Radian result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","Procedural::Utils::angleTo", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","Procedural::Utils::angleTo", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","Procedural::Utils::angleTo", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","Procedural::Utils::angleTo", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  {
    try {
      result = Procedural::Utils::angleTo((Ogre::Vector2 const &)*arg1,(Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Utils__compute_quaternion__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Quaternion result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Procedural::Utils::_computeQuaternion", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Procedural::Utils::_computeQuaternion", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Procedural::Utils::_computeQuaternion", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Procedural::Utils::_computeQuaternion", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = Procedural::Utils::_computeQuaternion((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Quaternion(static_cast< const Ogre::Quaternion& >(result))), SWIGTYPE_p_Ogre__Quaternion, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Utils__compute_quaternion__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::Quaternion result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Procedural::Utils::_computeQuaternion", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Procedural::Utils::_computeQuaternion", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  {
    try {
      result = Procedural::Utils::_computeQuaternion((Ogre::Vector3 const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Quaternion(static_cast< const Ogre::Quaternion& >(result))), SWIGTYPE_p_Ogre__Quaternion, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Utils__compute_quaternion(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Utils__compute_quaternion__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Utils__compute_quaternion__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Utils._compute_quaternion", 
    "    Ogre::Quaternion Utils._compute_quaternion(Ogre::Vector3 const &direction, Ogre::Vector3 const &upVector)\n"
    "    Ogre::Quaternion Utils._compute_quaternion(Ogre::Vector3 const &direction)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Utils_vec_2to_vec_3y(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::Vector3 result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","Procedural::Utils::vec2ToVec3Y", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","Procedural::Utils::vec2ToVec3Y", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  {
    try {
      result = Procedural::Utils::vec2ToVec3Y((Ogre::Vector2 const &)*arg1);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Utils_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Utils_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__Utils);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Utils(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::Utils";
  Procedural::Utils *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::Utils *)new Procedural::Utils();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_Utils(Procedural::Utils *arg1) {
    delete arg1;
}

swig_class SwigClassTriangleBuffer;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TriangleBuffer_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TriangleBuffer_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__TriangleBuffer);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TriangleBuffer(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::TriangleBuffer";
  Procedural::TriangleBuffer *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::TriangleBuffer *)new Procedural::TriangleBuffer();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_get_vertices__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< Vertex,std::allocator< Vertex > > *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","getVertices", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  {
    try {
      result = (std::vector< Vertex,std::allocator< Vertex > > *) &(arg1)->getVertices();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Vertex_std__allocatorT_Vertex_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_get_vertices__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< Vertex,std::allocator< Vertex > > *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer const *","getVertices", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  {
    try {
      result = (std::vector< Vertex,std::allocator< Vertex > > *) &((Procedural::TriangleBuffer const *)arg1)->getVertices();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Vertex_std__allocatorT_Vertex_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TriangleBuffer_get_vertices(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 2) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__TriangleBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TriangleBuffer_get_vertices__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__TriangleBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TriangleBuffer_get_vertices__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "TriangleBuffer.get_vertices", 
    "    std::vector< Vertex,std::allocator< Vertex > > const & TriangleBuffer.get_vertices()\n"
    "    std::vector< Vertex,std::allocator< Vertex > > const & TriangleBuffer.get_vertices()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_get_indices__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","getIndices", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  {
    try {
      result = (std::vector< int,std::allocator< int > > *) &(arg1)->getIndices();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_get_indices__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer const *","getIndices", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  {
    try {
      result = (std::vector< int,std::allocator< int > > *) &((Procedural::TriangleBuffer const *)arg1)->getIndices();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TriangleBuffer_get_indices(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 2) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__TriangleBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TriangleBuffer_get_indices__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__TriangleBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TriangleBuffer_get_indices__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "TriangleBuffer.get_indices", 
    "    std::vector< int,std::allocator< int > > const & TriangleBuffer.get_indices()\n"
    "    std::vector< int,std::allocator< int > > const & TriangleBuffer.get_indices()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_rebase_offset(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","rebaseOffset", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  {
    try {
      (arg1)->rebaseOffset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_transform_to_mesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  std::string *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","transformToMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","transformToMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","transformToMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","transformToMesh", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","transformToMesh", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (arg1)->transformToMesh((std::string const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_transform_to_mesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","transformToMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","transformToMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","transformToMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->transformToMesh((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_TriangleBuffer_transform_to_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__TriangleBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TriangleBuffer_transform_to_mesh__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__TriangleBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TriangleBuffer_transform_to_mesh__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TriangleBuffer.transform_to_mesh", 
    "    Ogre::MeshPtr TriangleBuffer.transform_to_mesh(std::string const &name, Ogre::String const &group)\n"
    "    Ogre::MeshPtr TriangleBuffer.transform_to_mesh(std::string const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::TriangleBuffer *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","position", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","position", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","position", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::TriangleBuffer *) &(arg1)->position((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::TriangleBuffer *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","position", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","position", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","position", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","position", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::TriangleBuffer *) &(arg1)->position(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TriangleBuffer_position(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__TriangleBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TriangleBuffer_position__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__TriangleBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TriangleBuffer_position__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TriangleBuffer.position", 
    "    Procedural::TriangleBuffer & TriangleBuffer.position(Ogre::Vector3 const &pos)\n"
    "    Procedural::TriangleBuffer & TriangleBuffer.position(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_normal(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::TriangleBuffer *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","normal", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","normal", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","normal", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::TriangleBuffer *) &(arg1)->normal((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_texture_coord__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  float arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Procedural::TriangleBuffer *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","textureCoord", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","textureCoord", 2, argv[0] ));
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "float","textureCoord", 3, argv[1] ));
  } 
  arg3 = static_cast< float >(val3);
  {
    try {
      result = (Procedural::TriangleBuffer *) &(arg1)->textureCoord(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_texture_coord__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::TriangleBuffer *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","textureCoord", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","textureCoord", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","textureCoord", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  {
    try {
      result = (Procedural::TriangleBuffer *) &(arg1)->textureCoord((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TriangleBuffer_texture_coord(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__TriangleBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TriangleBuffer_texture_coord__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__TriangleBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TriangleBuffer_texture_coord__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TriangleBuffer.texture_coord", 
    "    Procedural::TriangleBuffer & TriangleBuffer.texture_coord(float u, float v)\n"
    "    Procedural::TriangleBuffer & TriangleBuffer.texture_coord(Ogre::Vector2 const &vec)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_index(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::TriangleBuffer *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","index", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","index", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::TriangleBuffer *) &(arg1)->index(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_triangle(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Procedural::TriangleBuffer *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","triangle", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","triangle", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","triangle", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","triangle", 4, argv[2] ));
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (Procedural::TriangleBuffer *) &(arg1)->triangle(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_apply_transform(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  Ogre::Matrix4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::TriangleBuffer *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","applyTransform", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","applyTransform", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","applyTransform", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  {
    try {
      result = (Procedural::TriangleBuffer *) &(arg1)->applyTransform((Ogre::Matrix4 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_translate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::TriangleBuffer *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","translate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","translate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::TriangleBuffer *) &(arg1)->translate((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_translate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::TriangleBuffer *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","translate", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","translate", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","translate", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::TriangleBuffer *) &(arg1)->translate(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TriangleBuffer_translate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__TriangleBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TriangleBuffer_translate__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__TriangleBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TriangleBuffer_translate__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TriangleBuffer.translate", 
    "    Procedural::TriangleBuffer & TriangleBuffer.translate(Ogre::Vector3 const &amount)\n"
    "    Procedural::TriangleBuffer & TriangleBuffer.translate(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_rotate(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  Ogre::Quaternion arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::TriangleBuffer *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","rotate", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion","rotate", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion","rotate", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Quaternion * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::TriangleBuffer *) &(arg1)->rotate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::TriangleBuffer *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","scale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","scale", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","scale", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::TriangleBuffer *) &(arg1)->scale((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::TriangleBuffer *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","scale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","scale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","scale", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","scale", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::TriangleBuffer *) &(arg1)->scale(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TriangleBuffer_scale(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__TriangleBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TriangleBuffer_scale__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__TriangleBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TriangleBuffer_scale__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TriangleBuffer.scale", 
    "    Procedural::TriangleBuffer & TriangleBuffer.scale(Ogre::Vector3 const &scale)\n"
    "    Procedural::TriangleBuffer & TriangleBuffer.scale(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_invert_normals(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::TriangleBuffer *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","invertNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  {
    try {
      result = (Procedural::TriangleBuffer *) &(arg1)->invertNormals();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_estimate_vertex_count(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","estimateVertexCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","estimateVertexCount", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      (arg1)->estimateVertexCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer_estimate_index_count(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","estimateIndexCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","estimateIndexCount", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      (arg1)->estimateIndexCount(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TriangleBuffer__dump_contents_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::TriangleBuffer *arg1 = (Procedural::TriangleBuffer *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TriangleBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer *","_dumpContentsToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TriangleBuffer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","_dumpContentsToFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","_dumpContentsToFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->_dumpContentsToFile((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN void
free_Procedural_TriangleBuffer(Procedural::TriangleBuffer *arg1) {
    delete arg1;
}

swig_class SwigClassBoxMeshGenerator;

SWIGINTERN VALUE
_wrap_BoxMeshGenerator_realize_mesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::BoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::BoxGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::BoxGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::BoxGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","realizeMesh", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","realizeMesh", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxMeshGenerator_realize_mesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::BoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::BoxGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::BoxGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::BoxGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxMeshGenerator_realize_mesh__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::BoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::BoxGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::BoxGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::BoxGenerator > * >(argp1);
  {
    try {
      result = (arg1)->realizeMesh();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BoxMeshGenerator_realize_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BoxMeshGenerator_realize_mesh__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BoxMeshGenerator_realize_mesh__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BoxMeshGenerator_realize_mesh__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "BoxMeshGenerator.realize_mesh", 
    "    Ogre::MeshPtr BoxMeshGenerator.realize_mesh(std::string const &name, Ogre::String const &group)\n"
    "    Ogre::MeshPtr BoxMeshGenerator.realize_mesh(std::string const &name)\n"
    "    Ogre::MeshPtr BoxMeshGenerator.realize_mesh()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxMeshGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::BoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::BoxGenerator > *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::BoxGenerator > const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::BoxGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::MeshGenerator< Procedural::BoxGenerator > const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxMeshGenerator_set_utile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::BoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::BoxGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::BoxGenerator > *","setUTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::BoxGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setUTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->setUTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxMeshGenerator_set_vtile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::BoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::BoxGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::BoxGenerator > *","setVTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::BoxGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setVTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->setVTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxMeshGenerator_set_texture_rectangle(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::BoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::BoxGenerator > *) 0 ;
  Ogre::Rectangle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::BoxGenerator > *","setTextureRectangle", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::BoxGenerator > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Rectangle,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rectangle","setTextureRectangle", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rectangle","setTextureRectangle", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Rectangle * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->setTextureRectangle(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxMeshGenerator_set_enable_normals(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::BoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::BoxGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::BoxGenerator > *","setEnableNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::BoxGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setEnableNormals", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->setEnableNormals(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxMeshGenerator_set_num_tex_coord_set(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::BoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::BoxGenerator > *) 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::BoxGenerator > *","setNumTexCoordSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::BoxGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned char","setNumTexCoordSet", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned char >(val2);
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->setNumTexCoordSet(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxMeshGenerator_set_switch_uv(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::BoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::BoxGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::BoxGenerator > *","setSwitchUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::BoxGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSwitchUV", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->setSwitchUV(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxMeshGenerator_set_orientation(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::BoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::BoxGenerator > *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::BoxGenerator > *","setOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::BoxGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","setOrientation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","setOrientation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->setOrientation((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxMeshGenerator_set_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::BoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::BoxGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::BoxGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::BoxGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setPosition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setPosition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->setPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxMeshGenerator_set_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::BoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::BoxGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::BoxGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::BoxGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->setPosition(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BoxMeshGenerator_set_position(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BoxMeshGenerator_set_position__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BoxMeshGenerator_set_position__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "BoxMeshGenerator.set_position", 
    "    Procedural::BoxGenerator & BoxMeshGenerator.set_position(Ogre::Vector3 const &position)\n"
    "    Procedural::BoxGenerator & BoxMeshGenerator.set_position(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxMeshGenerator_set_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::BoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::BoxGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::BoxGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::BoxGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setScale", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setScale", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->setScale((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxMeshGenerator_set_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::BoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::BoxGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::BoxGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::BoxGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->setScale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxMeshGenerator_set_scale__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::BoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::BoxGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::BoxGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::BoxGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->setScale(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BoxMeshGenerator_set_scale(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BoxMeshGenerator_set_scale__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BoxMeshGenerator_set_scale__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BoxMeshGenerator_set_scale__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "BoxMeshGenerator.set_scale", 
    "    Procedural::BoxGenerator & BoxMeshGenerator.set_scale(Ogre::Vector3 const &scale)\n"
    "    Procedural::BoxGenerator & BoxMeshGenerator.set_scale(Ogre::Real scale)\n"
    "    Procedural::BoxGenerator & BoxMeshGenerator.set_scale(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxMeshGenerator_reset_transforms(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::BoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::BoxGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::BoxGenerator > *","resetTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::BoxGenerator > * >(argp1);
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->resetTransforms();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxMeshGenerator__set_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::BoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::BoxGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::BoxGenerator > *","_setDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::BoxGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","_setDumpToFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","_setDumpToFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->_setDumpToFile((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxMeshGenerator__disable_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::BoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::BoxGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::BoxGenerator > *","_disableDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::BoxGenerator > * >(argp1);
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->_disableDumpToFile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_MeshGenerator_Sl_Procedural_BoxGenerator_Sg_(Procedural::MeshGenerator< Procedural::BoxGenerator > *arg1) {
    delete arg1;
}

swig_class SwigClassBoxGenerator;

SWIGINTERN VALUE
_wrap_new_BoxGenerator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::BoxGenerator";
  Procedural::BoxGenerator *result = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::BoxGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::BoxGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::BoxGenerator", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","Procedural::BoxGenerator", 4, argv[3] ));
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","Procedural::BoxGenerator", 5, argv[4] ));
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "int","Procedural::BoxGenerator", 6, argv[5] ));
  } 
  arg6 = static_cast< int >(val6);
  {
    try {
      result = (Procedural::BoxGenerator *)new Procedural::BoxGenerator(arg1,arg2,arg3,arg4,arg5,arg6);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_BoxGenerator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  int arg4 ;
  int arg5 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::BoxGenerator";
  Procedural::BoxGenerator *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::BoxGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::BoxGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::BoxGenerator", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","Procedural::BoxGenerator", 4, argv[3] ));
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","Procedural::BoxGenerator", 5, argv[4] ));
  } 
  arg5 = static_cast< int >(val5);
  {
    try {
      result = (Procedural::BoxGenerator *)new Procedural::BoxGenerator(arg1,arg2,arg3,arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_BoxGenerator__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  int arg4 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::BoxGenerator";
  Procedural::BoxGenerator *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::BoxGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::BoxGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::BoxGenerator", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","Procedural::BoxGenerator", 4, argv[3] ));
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (Procedural::BoxGenerator *)new Procedural::BoxGenerator(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_BoxGenerator__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::BoxGenerator";
  Procedural::BoxGenerator *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::BoxGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::BoxGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::BoxGenerator", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  {
    try {
      result = (Procedural::BoxGenerator *)new Procedural::BoxGenerator(arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_BoxGenerator__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::BoxGenerator";
  Procedural::BoxGenerator *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::BoxGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::BoxGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::BoxGenerator *)new Procedural::BoxGenerator(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_BoxGenerator__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::BoxGenerator";
  Procedural::BoxGenerator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::BoxGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  {
    try {
      result = (Procedural::BoxGenerator *)new Procedural::BoxGenerator(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_BoxGenerator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_BoxGenerator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__BoxGenerator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_BoxGenerator__SWIG_6(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::BoxGenerator";
  Procedural::BoxGenerator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::BoxGenerator *)new Procedural::BoxGenerator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BoxGenerator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[6];
  int ii;
  
  argc = nargs;
  if (argc > 6) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_BoxGenerator__SWIG_6(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_BoxGenerator__SWIG_5(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_BoxGenerator__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_BoxGenerator__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_BoxGenerator__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_BoxGenerator__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_BoxGenerator__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "BoxGenerator.new", 
    "    BoxGenerator.new(Ogre::Real sizeX, Ogre::Real sizeY, Ogre::Real sizeZ, int numSegX, int numSegY, int numSegZ)\n"
    "    BoxGenerator.new(Ogre::Real sizeX, Ogre::Real sizeY, Ogre::Real sizeZ, int numSegX, int numSegY)\n"
    "    BoxGenerator.new(Ogre::Real sizeX, Ogre::Real sizeY, Ogre::Real sizeZ, int numSegX)\n"
    "    BoxGenerator.new(Ogre::Real sizeX, Ogre::Real sizeY, Ogre::Real sizeZ)\n"
    "    BoxGenerator.new(Ogre::Real sizeX, Ogre::Real sizeY)\n"
    "    BoxGenerator.new(Ogre::Real sizeX)\n"
    "    BoxGenerator.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxGenerator_set_size_x(int argc, VALUE *argv, VALUE self) {
  Procedural::BoxGenerator *arg1 = (Procedural::BoxGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::BoxGenerator *","setSizeX", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::BoxGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSizeX", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->setSizeX(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxGenerator_set_size_y(int argc, VALUE *argv, VALUE self) {
  Procedural::BoxGenerator *arg1 = (Procedural::BoxGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::BoxGenerator *","setSizeY", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::BoxGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSizeY", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->setSizeY(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxGenerator_set_size_z(int argc, VALUE *argv, VALUE self) {
  Procedural::BoxGenerator *arg1 = (Procedural::BoxGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::BoxGenerator *","setSizeZ", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::BoxGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSizeZ", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->setSizeZ(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxGenerator_set_size(int argc, VALUE *argv, VALUE self) {
  Procedural::BoxGenerator *arg1 = (Procedural::BoxGenerator *) 0 ;
  Ogre::Vector3 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::BoxGenerator *","setSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::BoxGenerator * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3","setSize", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3","setSize", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Vector3 * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->setSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxGenerator_set_num_seg_x(int argc, VALUE *argv, VALUE self) {
  Procedural::BoxGenerator *arg1 = (Procedural::BoxGenerator *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::BoxGenerator *","setNumSegX", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::BoxGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNumSegX", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->setNumSegX(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxGenerator_set_num_seg_y(int argc, VALUE *argv, VALUE self) {
  Procedural::BoxGenerator *arg1 = (Procedural::BoxGenerator *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::BoxGenerator *","setNumSegY", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::BoxGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNumSegY", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->setNumSegY(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxGenerator_set_num_seg_z(int argc, VALUE *argv, VALUE self) {
  Procedural::BoxGenerator *arg1 = (Procedural::BoxGenerator *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::BoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::BoxGenerator *","setNumSegZ", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::BoxGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNumSegZ", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::BoxGenerator *) &(arg1)->setNumSegZ(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BoxGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::BoxGenerator *arg1 = (Procedural::BoxGenerator *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__BoxGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::BoxGenerator const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::BoxGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::BoxGenerator const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_BoxGenerator(Procedural::BoxGenerator *arg1) {
    delete arg1;
}

swig_class SwigClassCapsuleMeshGenerator;

SWIGINTERN VALUE
_wrap_CapsuleMeshGenerator_realize_mesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CapsuleGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CapsuleGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CapsuleGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CapsuleGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","realizeMesh", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","realizeMesh", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleMeshGenerator_realize_mesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CapsuleGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CapsuleGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CapsuleGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CapsuleGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleMeshGenerator_realize_mesh__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CapsuleGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CapsuleGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CapsuleGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CapsuleGenerator > * >(argp1);
  {
    try {
      result = (arg1)->realizeMesh();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CapsuleMeshGenerator_realize_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CapsuleMeshGenerator_realize_mesh__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CapsuleMeshGenerator_realize_mesh__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CapsuleMeshGenerator_realize_mesh__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "CapsuleMeshGenerator.realize_mesh", 
    "    Ogre::MeshPtr CapsuleMeshGenerator.realize_mesh(std::string const &name, Ogre::String const &group)\n"
    "    Ogre::MeshPtr CapsuleMeshGenerator.realize_mesh(std::string const &name)\n"
    "    Ogre::MeshPtr CapsuleMeshGenerator.realize_mesh()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleMeshGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CapsuleGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CapsuleGenerator > *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CapsuleGenerator > const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CapsuleGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::MeshGenerator< Procedural::CapsuleGenerator > const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleMeshGenerator_set_utile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CapsuleGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CapsuleGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::CapsuleGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CapsuleGenerator > *","setUTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CapsuleGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setUTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::CapsuleGenerator *) &(arg1)->setUTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleMeshGenerator_set_vtile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CapsuleGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CapsuleGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::CapsuleGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CapsuleGenerator > *","setVTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CapsuleGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setVTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::CapsuleGenerator *) &(arg1)->setVTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleMeshGenerator_set_texture_rectangle(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CapsuleGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CapsuleGenerator > *) 0 ;
  Ogre::Rectangle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::CapsuleGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CapsuleGenerator > *","setTextureRectangle", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CapsuleGenerator > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Rectangle,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rectangle","setTextureRectangle", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rectangle","setTextureRectangle", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Rectangle * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::CapsuleGenerator *) &(arg1)->setTextureRectangle(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleMeshGenerator_set_enable_normals(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CapsuleGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CapsuleGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::CapsuleGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CapsuleGenerator > *","setEnableNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CapsuleGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setEnableNormals", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::CapsuleGenerator *) &(arg1)->setEnableNormals(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleMeshGenerator_set_num_tex_coord_set(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CapsuleGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CapsuleGenerator > *) 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  Procedural::CapsuleGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CapsuleGenerator > *","setNumTexCoordSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CapsuleGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned char","setNumTexCoordSet", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned char >(val2);
  {
    try {
      result = (Procedural::CapsuleGenerator *) &(arg1)->setNumTexCoordSet(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleMeshGenerator_set_switch_uv(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CapsuleGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CapsuleGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::CapsuleGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CapsuleGenerator > *","setSwitchUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CapsuleGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSwitchUV", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::CapsuleGenerator *) &(arg1)->setSwitchUV(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleMeshGenerator_set_orientation(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CapsuleGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CapsuleGenerator > *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::CapsuleGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CapsuleGenerator > *","setOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CapsuleGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","setOrientation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","setOrientation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  {
    try {
      result = (Procedural::CapsuleGenerator *) &(arg1)->setOrientation((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleMeshGenerator_set_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CapsuleGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CapsuleGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::CapsuleGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CapsuleGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CapsuleGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setPosition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setPosition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::CapsuleGenerator *) &(arg1)->setPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleMeshGenerator_set_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CapsuleGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CapsuleGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::CapsuleGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CapsuleGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CapsuleGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::CapsuleGenerator *) &(arg1)->setPosition(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CapsuleMeshGenerator_set_position(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CapsuleMeshGenerator_set_position__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_CapsuleMeshGenerator_set_position__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "CapsuleMeshGenerator.set_position", 
    "    Procedural::CapsuleGenerator & CapsuleMeshGenerator.set_position(Ogre::Vector3 const &position)\n"
    "    Procedural::CapsuleGenerator & CapsuleMeshGenerator.set_position(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleMeshGenerator_set_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CapsuleGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CapsuleGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::CapsuleGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CapsuleGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CapsuleGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setScale", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setScale", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::CapsuleGenerator *) &(arg1)->setScale((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleMeshGenerator_set_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CapsuleGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CapsuleGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::CapsuleGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CapsuleGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CapsuleGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::CapsuleGenerator *) &(arg1)->setScale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleMeshGenerator_set_scale__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CapsuleGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CapsuleGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::CapsuleGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CapsuleGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CapsuleGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::CapsuleGenerator *) &(arg1)->setScale(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CapsuleMeshGenerator_set_scale(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CapsuleMeshGenerator_set_scale__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CapsuleMeshGenerator_set_scale__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_CapsuleMeshGenerator_set_scale__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "CapsuleMeshGenerator.set_scale", 
    "    Procedural::CapsuleGenerator & CapsuleMeshGenerator.set_scale(Ogre::Vector3 const &scale)\n"
    "    Procedural::CapsuleGenerator & CapsuleMeshGenerator.set_scale(Ogre::Real scale)\n"
    "    Procedural::CapsuleGenerator & CapsuleMeshGenerator.set_scale(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleMeshGenerator_reset_transforms(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CapsuleGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CapsuleGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::CapsuleGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CapsuleGenerator > *","resetTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CapsuleGenerator > * >(argp1);
  {
    try {
      result = (Procedural::CapsuleGenerator *) &(arg1)->resetTransforms();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleMeshGenerator__set_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CapsuleGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CapsuleGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Procedural::CapsuleGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CapsuleGenerator > *","_setDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CapsuleGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","_setDumpToFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","_setDumpToFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Procedural::CapsuleGenerator *) &(arg1)->_setDumpToFile((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleMeshGenerator__disable_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CapsuleGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CapsuleGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::CapsuleGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CapsuleGenerator > *","_disableDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CapsuleGenerator > * >(argp1);
  {
    try {
      result = (Procedural::CapsuleGenerator *) &(arg1)->_disableDumpToFile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_MeshGenerator_Sl_Procedural_CapsuleGenerator_Sg_(Procedural::MeshGenerator< Procedural::CapsuleGenerator > *arg1) {
    delete arg1;
}

swig_class SwigClassCapsuleGenerator;

SWIGINTERN VALUE
_wrap_new_CapsuleGenerator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::CapsuleGenerator";
  Procedural::CapsuleGenerator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::CapsuleGenerator *)new Procedural::CapsuleGenerator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CapsuleGenerator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CapsuleGenerator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__CapsuleGenerator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CapsuleGenerator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::CapsuleGenerator";
  Procedural::CapsuleGenerator *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::CapsuleGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::CapsuleGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","Procedural::CapsuleGenerator", 3, argv[2] ));
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","Procedural::CapsuleGenerator", 4, argv[3] ));
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "unsigned int","Procedural::CapsuleGenerator", 5, argv[4] ));
  } 
  arg5 = static_cast< unsigned int >(val5);
  {
    try {
      result = (Procedural::CapsuleGenerator *)new Procedural::CapsuleGenerator(arg1,arg2,arg3,arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CapsuleGenerator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs;
  if (argc > 5) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CapsuleGenerator__SWIG_0(nargs, args, self);
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_CapsuleGenerator__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "CapsuleGenerator.new", 
    "    CapsuleGenerator.new()\n"
    "    CapsuleGenerator.new(Ogre::Real radius, Ogre::Real height, unsigned int numRings, unsigned int numSegments, unsigned int numSegHeight)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::CapsuleGenerator *arg1 = (Procedural::CapsuleGenerator *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CapsuleGenerator const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CapsuleGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::CapsuleGenerator const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleGenerator_set_radius(int argc, VALUE *argv, VALUE self) {
  Procedural::CapsuleGenerator *arg1 = (Procedural::CapsuleGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::CapsuleGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CapsuleGenerator *","setRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CapsuleGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::CapsuleGenerator *) &(arg1)->setRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleGenerator_set_num_rings(int argc, VALUE *argv, VALUE self) {
  Procedural::CapsuleGenerator *arg1 = (Procedural::CapsuleGenerator *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Procedural::CapsuleGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CapsuleGenerator *","setNumRings", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CapsuleGenerator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","setNumRings", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Procedural::CapsuleGenerator *) &(arg1)->setNumRings(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleGenerator_set_num_segments(int argc, VALUE *argv, VALUE self) {
  Procedural::CapsuleGenerator *arg1 = (Procedural::CapsuleGenerator *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Procedural::CapsuleGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CapsuleGenerator *","setNumSegments", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CapsuleGenerator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","setNumSegments", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Procedural::CapsuleGenerator *) &(arg1)->setNumSegments(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleGenerator_set_num_seg_height(int argc, VALUE *argv, VALUE self) {
  Procedural::CapsuleGenerator *arg1 = (Procedural::CapsuleGenerator *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Procedural::CapsuleGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CapsuleGenerator *","setNumSegHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CapsuleGenerator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","setNumSegHeight", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Procedural::CapsuleGenerator *) &(arg1)->setNumSegHeight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CapsuleGenerator_set_height(int argc, VALUE *argv, VALUE self) {
  Procedural::CapsuleGenerator *arg1 = (Procedural::CapsuleGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::CapsuleGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CapsuleGenerator *","setHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CapsuleGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setHeight", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::CapsuleGenerator *) &(arg1)->setHeight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CapsuleGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_CapsuleGenerator(Procedural::CapsuleGenerator *arg1) {
    delete arg1;
}

swig_class SwigClassConeMeshGenerator;

SWIGINTERN VALUE
_wrap_ConeMeshGenerator_realize_mesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::ConeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::ConeGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::ConeGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::ConeGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","realizeMesh", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","realizeMesh", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeMeshGenerator_realize_mesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::ConeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::ConeGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::ConeGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::ConeGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeMeshGenerator_realize_mesh__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::ConeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::ConeGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::ConeGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::ConeGenerator > * >(argp1);
  {
    try {
      result = (arg1)->realizeMesh();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ConeMeshGenerator_realize_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ConeMeshGenerator_realize_mesh__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ConeMeshGenerator_realize_mesh__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ConeMeshGenerator_realize_mesh__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ConeMeshGenerator.realize_mesh", 
    "    Ogre::MeshPtr ConeMeshGenerator.realize_mesh(std::string const &name, Ogre::String const &group)\n"
    "    Ogre::MeshPtr ConeMeshGenerator.realize_mesh(std::string const &name)\n"
    "    Ogre::MeshPtr ConeMeshGenerator.realize_mesh()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeMeshGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::ConeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::ConeGenerator > *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::ConeGenerator > const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::ConeGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::MeshGenerator< Procedural::ConeGenerator > const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeMeshGenerator_set_utile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::ConeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::ConeGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::ConeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::ConeGenerator > *","setUTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::ConeGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setUTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::ConeGenerator *) &(arg1)->setUTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeMeshGenerator_set_vtile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::ConeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::ConeGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::ConeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::ConeGenerator > *","setVTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::ConeGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setVTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::ConeGenerator *) &(arg1)->setVTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeMeshGenerator_set_texture_rectangle(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::ConeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::ConeGenerator > *) 0 ;
  Ogre::Rectangle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::ConeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::ConeGenerator > *","setTextureRectangle", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::ConeGenerator > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Rectangle,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rectangle","setTextureRectangle", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rectangle","setTextureRectangle", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Rectangle * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::ConeGenerator *) &(arg1)->setTextureRectangle(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeMeshGenerator_set_enable_normals(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::ConeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::ConeGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::ConeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::ConeGenerator > *","setEnableNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::ConeGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setEnableNormals", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::ConeGenerator *) &(arg1)->setEnableNormals(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeMeshGenerator_set_num_tex_coord_set(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::ConeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::ConeGenerator > *) 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  Procedural::ConeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::ConeGenerator > *","setNumTexCoordSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::ConeGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned char","setNumTexCoordSet", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned char >(val2);
  {
    try {
      result = (Procedural::ConeGenerator *) &(arg1)->setNumTexCoordSet(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeMeshGenerator_set_switch_uv(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::ConeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::ConeGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::ConeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::ConeGenerator > *","setSwitchUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::ConeGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSwitchUV", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::ConeGenerator *) &(arg1)->setSwitchUV(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeMeshGenerator_set_orientation(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::ConeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::ConeGenerator > *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::ConeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::ConeGenerator > *","setOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::ConeGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","setOrientation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","setOrientation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  {
    try {
      result = (Procedural::ConeGenerator *) &(arg1)->setOrientation((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeMeshGenerator_set_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::ConeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::ConeGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::ConeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::ConeGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::ConeGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setPosition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setPosition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::ConeGenerator *) &(arg1)->setPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeMeshGenerator_set_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::ConeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::ConeGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::ConeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::ConeGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::ConeGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::ConeGenerator *) &(arg1)->setPosition(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ConeMeshGenerator_set_position(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ConeMeshGenerator_set_position__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ConeMeshGenerator_set_position__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ConeMeshGenerator.set_position", 
    "    Procedural::ConeGenerator & ConeMeshGenerator.set_position(Ogre::Vector3 const &position)\n"
    "    Procedural::ConeGenerator & ConeMeshGenerator.set_position(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeMeshGenerator_set_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::ConeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::ConeGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::ConeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::ConeGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::ConeGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setScale", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setScale", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::ConeGenerator *) &(arg1)->setScale((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeMeshGenerator_set_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::ConeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::ConeGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::ConeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::ConeGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::ConeGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::ConeGenerator *) &(arg1)->setScale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeMeshGenerator_set_scale__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::ConeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::ConeGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::ConeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::ConeGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::ConeGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::ConeGenerator *) &(arg1)->setScale(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ConeMeshGenerator_set_scale(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ConeMeshGenerator_set_scale__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ConeMeshGenerator_set_scale__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ConeMeshGenerator_set_scale__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ConeMeshGenerator.set_scale", 
    "    Procedural::ConeGenerator & ConeMeshGenerator.set_scale(Ogre::Vector3 const &scale)\n"
    "    Procedural::ConeGenerator & ConeMeshGenerator.set_scale(Ogre::Real scale)\n"
    "    Procedural::ConeGenerator & ConeMeshGenerator.set_scale(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeMeshGenerator_reset_transforms(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::ConeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::ConeGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::ConeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::ConeGenerator > *","resetTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::ConeGenerator > * >(argp1);
  {
    try {
      result = (Procedural::ConeGenerator *) &(arg1)->resetTransforms();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeMeshGenerator__set_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::ConeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::ConeGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Procedural::ConeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::ConeGenerator > *","_setDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::ConeGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","_setDumpToFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","_setDumpToFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Procedural::ConeGenerator *) &(arg1)->_setDumpToFile((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeMeshGenerator__disable_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::ConeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::ConeGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::ConeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::ConeGenerator > *","_disableDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::ConeGenerator > * >(argp1);
  {
    try {
      result = (Procedural::ConeGenerator *) &(arg1)->_disableDumpToFile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_MeshGenerator_Sl_Procedural_ConeGenerator_Sg_(Procedural::MeshGenerator< Procedural::ConeGenerator > *arg1) {
    delete arg1;
}

swig_class SwigClassConeGenerator;

SWIGINTERN VALUE
_wrap_new_ConeGenerator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  int arg3 ;
  int arg4 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::ConeGenerator";
  Procedural::ConeGenerator *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::ConeGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::ConeGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Procedural::ConeGenerator", 3, argv[2] ));
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","Procedural::ConeGenerator", 4, argv[3] ));
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (Procedural::ConeGenerator *)new Procedural::ConeGenerator(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_ConeGenerator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  int arg3 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::ConeGenerator";
  Procedural::ConeGenerator *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::ConeGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::ConeGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Procedural::ConeGenerator", 3, argv[2] ));
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (Procedural::ConeGenerator *)new Procedural::ConeGenerator(arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_ConeGenerator__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::ConeGenerator";
  Procedural::ConeGenerator *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::ConeGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::ConeGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::ConeGenerator *)new Procedural::ConeGenerator(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_ConeGenerator__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::ConeGenerator";
  Procedural::ConeGenerator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::ConeGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  {
    try {
      result = (Procedural::ConeGenerator *)new Procedural::ConeGenerator(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_ConeGenerator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_ConeGenerator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__ConeGenerator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_ConeGenerator__SWIG_4(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::ConeGenerator";
  Procedural::ConeGenerator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::ConeGenerator *)new Procedural::ConeGenerator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ConeGenerator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_ConeGenerator__SWIG_4(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ConeGenerator__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ConeGenerator__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ConeGenerator__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_ConeGenerator__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ConeGenerator.new", 
    "    ConeGenerator.new(Ogre::Real radius, Ogre::Real height, int numSegBase, int numSegHeight)\n"
    "    ConeGenerator.new(Ogre::Real radius, Ogre::Real height, int numSegBase)\n"
    "    ConeGenerator.new(Ogre::Real radius, Ogre::Real height)\n"
    "    ConeGenerator.new(Ogre::Real radius)\n"
    "    ConeGenerator.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::ConeGenerator *arg1 = (Procedural::ConeGenerator *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::ConeGenerator const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::ConeGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::ConeGenerator const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeGenerator_set_num_seg_base(int argc, VALUE *argv, VALUE self) {
  Procedural::ConeGenerator *arg1 = (Procedural::ConeGenerator *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::ConeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::ConeGenerator *","setNumSegBase", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::ConeGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNumSegBase", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::ConeGenerator *) &(arg1)->setNumSegBase(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeGenerator_set_num_seg_height(int argc, VALUE *argv, VALUE self) {
  Procedural::ConeGenerator *arg1 = (Procedural::ConeGenerator *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::ConeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::ConeGenerator *","setNumSegHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::ConeGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNumSegHeight", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::ConeGenerator *) &(arg1)->setNumSegHeight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeGenerator_set_radius(int argc, VALUE *argv, VALUE self) {
  Procedural::ConeGenerator *arg1 = (Procedural::ConeGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::ConeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::ConeGenerator *","setRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::ConeGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::ConeGenerator *) &(arg1)->setRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConeGenerator_set_height(int argc, VALUE *argv, VALUE self) {
  Procedural::ConeGenerator *arg1 = (Procedural::ConeGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::ConeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::ConeGenerator *","setHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::ConeGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setHeight", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::ConeGenerator *) &(arg1)->setHeight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__ConeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_ConeGenerator(Procedural::ConeGenerator *arg1) {
    delete arg1;
}

swig_class SwigClassCylinderMeshGenerator;

SWIGINTERN VALUE
_wrap_CylinderMeshGenerator_realize_mesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CylinderGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CylinderGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CylinderGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CylinderGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","realizeMesh", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","realizeMesh", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderMeshGenerator_realize_mesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CylinderGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CylinderGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CylinderGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CylinderGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderMeshGenerator_realize_mesh__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CylinderGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CylinderGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CylinderGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CylinderGenerator > * >(argp1);
  {
    try {
      result = (arg1)->realizeMesh();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CylinderMeshGenerator_realize_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CylinderMeshGenerator_realize_mesh__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CylinderMeshGenerator_realize_mesh__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CylinderMeshGenerator_realize_mesh__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "CylinderMeshGenerator.realize_mesh", 
    "    Ogre::MeshPtr CylinderMeshGenerator.realize_mesh(std::string const &name, Ogre::String const &group)\n"
    "    Ogre::MeshPtr CylinderMeshGenerator.realize_mesh(std::string const &name)\n"
    "    Ogre::MeshPtr CylinderMeshGenerator.realize_mesh()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderMeshGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CylinderGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CylinderGenerator > *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CylinderGenerator > const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CylinderGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::MeshGenerator< Procedural::CylinderGenerator > const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderMeshGenerator_set_utile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CylinderGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CylinderGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::CylinderGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CylinderGenerator > *","setUTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CylinderGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setUTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::CylinderGenerator *) &(arg1)->setUTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderMeshGenerator_set_vtile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CylinderGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CylinderGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::CylinderGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CylinderGenerator > *","setVTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CylinderGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setVTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::CylinderGenerator *) &(arg1)->setVTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderMeshGenerator_set_texture_rectangle(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CylinderGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CylinderGenerator > *) 0 ;
  Ogre::Rectangle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::CylinderGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CylinderGenerator > *","setTextureRectangle", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CylinderGenerator > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Rectangle,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rectangle","setTextureRectangle", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rectangle","setTextureRectangle", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Rectangle * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::CylinderGenerator *) &(arg1)->setTextureRectangle(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderMeshGenerator_set_enable_normals(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CylinderGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CylinderGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::CylinderGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CylinderGenerator > *","setEnableNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CylinderGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setEnableNormals", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::CylinderGenerator *) &(arg1)->setEnableNormals(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderMeshGenerator_set_num_tex_coord_set(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CylinderGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CylinderGenerator > *) 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  Procedural::CylinderGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CylinderGenerator > *","setNumTexCoordSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CylinderGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned char","setNumTexCoordSet", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned char >(val2);
  {
    try {
      result = (Procedural::CylinderGenerator *) &(arg1)->setNumTexCoordSet(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderMeshGenerator_set_switch_uv(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CylinderGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CylinderGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::CylinderGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CylinderGenerator > *","setSwitchUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CylinderGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSwitchUV", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::CylinderGenerator *) &(arg1)->setSwitchUV(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderMeshGenerator_set_orientation(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CylinderGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CylinderGenerator > *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::CylinderGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CylinderGenerator > *","setOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CylinderGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","setOrientation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","setOrientation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  {
    try {
      result = (Procedural::CylinderGenerator *) &(arg1)->setOrientation((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderMeshGenerator_set_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CylinderGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CylinderGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::CylinderGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CylinderGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CylinderGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setPosition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setPosition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::CylinderGenerator *) &(arg1)->setPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderMeshGenerator_set_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CylinderGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CylinderGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::CylinderGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CylinderGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CylinderGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::CylinderGenerator *) &(arg1)->setPosition(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CylinderMeshGenerator_set_position(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CylinderMeshGenerator_set_position__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_CylinderMeshGenerator_set_position__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "CylinderMeshGenerator.set_position", 
    "    Procedural::CylinderGenerator & CylinderMeshGenerator.set_position(Ogre::Vector3 const &position)\n"
    "    Procedural::CylinderGenerator & CylinderMeshGenerator.set_position(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderMeshGenerator_set_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CylinderGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CylinderGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::CylinderGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CylinderGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CylinderGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setScale", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setScale", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::CylinderGenerator *) &(arg1)->setScale((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderMeshGenerator_set_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CylinderGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CylinderGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::CylinderGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CylinderGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CylinderGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::CylinderGenerator *) &(arg1)->setScale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderMeshGenerator_set_scale__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CylinderGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CylinderGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::CylinderGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CylinderGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CylinderGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::CylinderGenerator *) &(arg1)->setScale(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CylinderMeshGenerator_set_scale(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CylinderMeshGenerator_set_scale__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CylinderMeshGenerator_set_scale__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_CylinderMeshGenerator_set_scale__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "CylinderMeshGenerator.set_scale", 
    "    Procedural::CylinderGenerator & CylinderMeshGenerator.set_scale(Ogre::Vector3 const &scale)\n"
    "    Procedural::CylinderGenerator & CylinderMeshGenerator.set_scale(Ogre::Real scale)\n"
    "    Procedural::CylinderGenerator & CylinderMeshGenerator.set_scale(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderMeshGenerator_reset_transforms(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CylinderGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CylinderGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::CylinderGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CylinderGenerator > *","resetTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CylinderGenerator > * >(argp1);
  {
    try {
      result = (Procedural::CylinderGenerator *) &(arg1)->resetTransforms();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderMeshGenerator__set_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CylinderGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CylinderGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Procedural::CylinderGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CylinderGenerator > *","_setDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CylinderGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","_setDumpToFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","_setDumpToFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Procedural::CylinderGenerator *) &(arg1)->_setDumpToFile((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderMeshGenerator__disable_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::CylinderGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::CylinderGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::CylinderGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::CylinderGenerator > *","_disableDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::CylinderGenerator > * >(argp1);
  {
    try {
      result = (Procedural::CylinderGenerator *) &(arg1)->_disableDumpToFile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_MeshGenerator_Sl_Procedural_CylinderGenerator_Sg_(Procedural::MeshGenerator< Procedural::CylinderGenerator > *arg1) {
    delete arg1;
}

swig_class SwigClassCylinderGenerator;

SWIGINTERN VALUE
_wrap_new_CylinderGenerator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  int arg3 ;
  int arg4 ;
  bool arg5 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::CylinderGenerator";
  Procedural::CylinderGenerator *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::CylinderGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::CylinderGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Procedural::CylinderGenerator", 3, argv[2] ));
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","Procedural::CylinderGenerator", 4, argv[3] ));
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Procedural::CylinderGenerator", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (Procedural::CylinderGenerator *)new Procedural::CylinderGenerator(arg1,arg2,arg3,arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_CylinderGenerator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  int arg3 ;
  int arg4 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::CylinderGenerator";
  Procedural::CylinderGenerator *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::CylinderGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::CylinderGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Procedural::CylinderGenerator", 3, argv[2] ));
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","Procedural::CylinderGenerator", 4, argv[3] ));
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (Procedural::CylinderGenerator *)new Procedural::CylinderGenerator(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_CylinderGenerator__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  int arg3 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::CylinderGenerator";
  Procedural::CylinderGenerator *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::CylinderGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::CylinderGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Procedural::CylinderGenerator", 3, argv[2] ));
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (Procedural::CylinderGenerator *)new Procedural::CylinderGenerator(arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_CylinderGenerator__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::CylinderGenerator";
  Procedural::CylinderGenerator *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::CylinderGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::CylinderGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::CylinderGenerator *)new Procedural::CylinderGenerator(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_CylinderGenerator__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::CylinderGenerator";
  Procedural::CylinderGenerator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::CylinderGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  {
    try {
      result = (Procedural::CylinderGenerator *)new Procedural::CylinderGenerator(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CylinderGenerator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CylinderGenerator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__CylinderGenerator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CylinderGenerator__SWIG_5(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::CylinderGenerator";
  Procedural::CylinderGenerator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::CylinderGenerator *)new Procedural::CylinderGenerator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CylinderGenerator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs;
  if (argc > 5) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CylinderGenerator__SWIG_5(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CylinderGenerator__SWIG_4(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_CylinderGenerator__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_CylinderGenerator__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_CylinderGenerator__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_CylinderGenerator__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "CylinderGenerator.new", 
    "    CylinderGenerator.new(Ogre::Real radius, Ogre::Real height, int numSegBase, int numSegHeight, bool capped)\n"
    "    CylinderGenerator.new(Ogre::Real radius, Ogre::Real height, int numSegBase, int numSegHeight)\n"
    "    CylinderGenerator.new(Ogre::Real radius, Ogre::Real height, int numSegBase)\n"
    "    CylinderGenerator.new(Ogre::Real radius, Ogre::Real height)\n"
    "    CylinderGenerator.new(Ogre::Real radius)\n"
    "    CylinderGenerator.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::CylinderGenerator *arg1 = (Procedural::CylinderGenerator *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CylinderGenerator const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CylinderGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::CylinderGenerator const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderGenerator_set_num_seg_base(int argc, VALUE *argv, VALUE self) {
  Procedural::CylinderGenerator *arg1 = (Procedural::CylinderGenerator *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::CylinderGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CylinderGenerator *","setNumSegBase", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CylinderGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNumSegBase", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::CylinderGenerator *) &(arg1)->setNumSegBase(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderGenerator_set_num_seg_height(int argc, VALUE *argv, VALUE self) {
  Procedural::CylinderGenerator *arg1 = (Procedural::CylinderGenerator *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::CylinderGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CylinderGenerator *","setNumSegHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CylinderGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNumSegHeight", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::CylinderGenerator *) &(arg1)->setNumSegHeight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderGenerator_set_capped(int argc, VALUE *argv, VALUE self) {
  Procedural::CylinderGenerator *arg1 = (Procedural::CylinderGenerator *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::CylinderGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CylinderGenerator *","setCapped", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CylinderGenerator * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setCapped", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::CylinderGenerator *) &(arg1)->setCapped(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderGenerator_set_radius(int argc, VALUE *argv, VALUE self) {
  Procedural::CylinderGenerator *arg1 = (Procedural::CylinderGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::CylinderGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CylinderGenerator *","setRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CylinderGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::CylinderGenerator *) &(arg1)->setRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CylinderGenerator_set_height(int argc, VALUE *argv, VALUE self) {
  Procedural::CylinderGenerator *arg1 = (Procedural::CylinderGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::CylinderGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CylinderGenerator *","setHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CylinderGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setHeight", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::CylinderGenerator *) &(arg1)->setHeight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CylinderGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_CylinderGenerator(Procedural::CylinderGenerator *arg1) {
    delete arg1;
}

swig_class SwigClassIcoSphereMeshGenerator;

SWIGINTERN VALUE
_wrap_IcoSphereMeshGenerator_realize_mesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::IcoSphereGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","realizeMesh", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","realizeMesh", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereMeshGenerator_realize_mesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::IcoSphereGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereMeshGenerator_realize_mesh__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::IcoSphereGenerator > * >(argp1);
  {
    try {
      result = (arg1)->realizeMesh();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_IcoSphereMeshGenerator_realize_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_IcoSphereMeshGenerator_realize_mesh__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_IcoSphereMeshGenerator_realize_mesh__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IcoSphereMeshGenerator_realize_mesh__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "IcoSphereMeshGenerator.realize_mesh", 
    "    Ogre::MeshPtr IcoSphereMeshGenerator.realize_mesh(std::string const &name, Ogre::String const &group)\n"
    "    Ogre::MeshPtr IcoSphereMeshGenerator.realize_mesh(std::string const &name)\n"
    "    Ogre::MeshPtr IcoSphereMeshGenerator.realize_mesh()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereMeshGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::IcoSphereGenerator > const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::IcoSphereGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::MeshGenerator< Procedural::IcoSphereGenerator > const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereMeshGenerator_set_utile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::IcoSphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *","setUTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::IcoSphereGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setUTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::IcoSphereGenerator *) &(arg1)->setUTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__IcoSphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereMeshGenerator_set_vtile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::IcoSphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *","setVTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::IcoSphereGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setVTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::IcoSphereGenerator *) &(arg1)->setVTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__IcoSphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereMeshGenerator_set_texture_rectangle(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *) 0 ;
  Ogre::Rectangle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::IcoSphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *","setTextureRectangle", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::IcoSphereGenerator > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Rectangle,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rectangle","setTextureRectangle", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rectangle","setTextureRectangle", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Rectangle * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::IcoSphereGenerator *) &(arg1)->setTextureRectangle(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__IcoSphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereMeshGenerator_set_enable_normals(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::IcoSphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *","setEnableNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::IcoSphereGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setEnableNormals", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::IcoSphereGenerator *) &(arg1)->setEnableNormals(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__IcoSphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereMeshGenerator_set_num_tex_coord_set(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *) 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  Procedural::IcoSphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *","setNumTexCoordSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::IcoSphereGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned char","setNumTexCoordSet", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned char >(val2);
  {
    try {
      result = (Procedural::IcoSphereGenerator *) &(arg1)->setNumTexCoordSet(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__IcoSphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereMeshGenerator_set_switch_uv(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::IcoSphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *","setSwitchUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::IcoSphereGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSwitchUV", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::IcoSphereGenerator *) &(arg1)->setSwitchUV(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__IcoSphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereMeshGenerator_set_orientation(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::IcoSphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *","setOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::IcoSphereGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","setOrientation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","setOrientation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  {
    try {
      result = (Procedural::IcoSphereGenerator *) &(arg1)->setOrientation((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__IcoSphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereMeshGenerator_set_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::IcoSphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::IcoSphereGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setPosition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setPosition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::IcoSphereGenerator *) &(arg1)->setPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__IcoSphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereMeshGenerator_set_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::IcoSphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::IcoSphereGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::IcoSphereGenerator *) &(arg1)->setPosition(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__IcoSphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_IcoSphereMeshGenerator_set_position(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_IcoSphereMeshGenerator_set_position__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_IcoSphereMeshGenerator_set_position__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "IcoSphereMeshGenerator.set_position", 
    "    Procedural::IcoSphereGenerator & IcoSphereMeshGenerator.set_position(Ogre::Vector3 const &position)\n"
    "    Procedural::IcoSphereGenerator & IcoSphereMeshGenerator.set_position(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereMeshGenerator_set_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::IcoSphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::IcoSphereGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setScale", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setScale", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::IcoSphereGenerator *) &(arg1)->setScale((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__IcoSphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereMeshGenerator_set_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::IcoSphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::IcoSphereGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::IcoSphereGenerator *) &(arg1)->setScale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__IcoSphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereMeshGenerator_set_scale__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::IcoSphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::IcoSphereGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::IcoSphereGenerator *) &(arg1)->setScale(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__IcoSphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_IcoSphereMeshGenerator_set_scale(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_IcoSphereMeshGenerator_set_scale__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_IcoSphereMeshGenerator_set_scale__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_IcoSphereMeshGenerator_set_scale__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "IcoSphereMeshGenerator.set_scale", 
    "    Procedural::IcoSphereGenerator & IcoSphereMeshGenerator.set_scale(Ogre::Vector3 const &scale)\n"
    "    Procedural::IcoSphereGenerator & IcoSphereMeshGenerator.set_scale(Ogre::Real scale)\n"
    "    Procedural::IcoSphereGenerator & IcoSphereMeshGenerator.set_scale(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereMeshGenerator_reset_transforms(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::IcoSphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *","resetTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::IcoSphereGenerator > * >(argp1);
  {
    try {
      result = (Procedural::IcoSphereGenerator *) &(arg1)->resetTransforms();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__IcoSphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereMeshGenerator__set_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Procedural::IcoSphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *","_setDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::IcoSphereGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","_setDumpToFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","_setDumpToFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Procedural::IcoSphereGenerator *) &(arg1)->_setDumpToFile((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__IcoSphereGenerator, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereMeshGenerator__disable_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::IcoSphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *","_disableDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::IcoSphereGenerator > * >(argp1);
  {
    try {
      result = (Procedural::IcoSphereGenerator *) &(arg1)->_disableDumpToFile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__IcoSphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_MeshGenerator_Sl_Procedural_IcoSphereGenerator_Sg_(Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *arg1) {
    delete arg1;
}

swig_class SwigClassIcoSphereGenerator;

SWIGINTERN VALUE
_wrap_new_IcoSphereGenerator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  unsigned int arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::IcoSphereGenerator";
  Procedural::IcoSphereGenerator *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::IcoSphereGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","Procedural::IcoSphereGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Procedural::IcoSphereGenerator *)new Procedural::IcoSphereGenerator(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_IcoSphereGenerator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::IcoSphereGenerator";
  Procedural::IcoSphereGenerator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::IcoSphereGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  {
    try {
      result = (Procedural::IcoSphereGenerator *)new Procedural::IcoSphereGenerator(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_IcoSphereGenerator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_IcoSphereGenerator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__IcoSphereGenerator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_IcoSphereGenerator__SWIG_2(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::IcoSphereGenerator";
  Procedural::IcoSphereGenerator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::IcoSphereGenerator *)new Procedural::IcoSphereGenerator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IcoSphereGenerator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_IcoSphereGenerator__SWIG_2(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_IcoSphereGenerator__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_IcoSphereGenerator__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "IcoSphereGenerator.new", 
    "    IcoSphereGenerator.new(Ogre::Real radius, unsigned int numIterations)\n"
    "    IcoSphereGenerator.new(Ogre::Real radius)\n"
    "    IcoSphereGenerator.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::IcoSphereGenerator *arg1 = (Procedural::IcoSphereGenerator *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__IcoSphereGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::IcoSphereGenerator const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::IcoSphereGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::IcoSphereGenerator const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereGenerator_set_radius(int argc, VALUE *argv, VALUE self) {
  Procedural::IcoSphereGenerator *arg1 = (Procedural::IcoSphereGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::IcoSphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__IcoSphereGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::IcoSphereGenerator *","setRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::IcoSphereGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::IcoSphereGenerator *) &(arg1)->setRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__IcoSphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IcoSphereGenerator_set_num_iterations(int argc, VALUE *argv, VALUE self) {
  Procedural::IcoSphereGenerator *arg1 = (Procedural::IcoSphereGenerator *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Procedural::IcoSphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__IcoSphereGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::IcoSphereGenerator *","setNumIterations", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::IcoSphereGenerator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","setNumIterations", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Procedural::IcoSphereGenerator *) &(arg1)->setNumIterations(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__IcoSphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_IcoSphereGenerator(Procedural::IcoSphereGenerator *arg1) {
    delete arg1;
}

swig_class SwigClassMultiShape;

SWIGINTERN VALUE
_wrap_new_MultiShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::MultiShape";
  Procedural::MultiShape *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::MultiShape *)new Procedural::MultiShape();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MultiShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::MultiShape";
  Procedural::MultiShape *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Procedural__Shape,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const &","Procedural::MultiShape", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::Shape const &","Procedural::MultiShape", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    try {
      result = (Procedural::MultiShape *)new Procedural::MultiShape((Procedural::Shape const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_MultiShape_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_MultiShape_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__MultiShape);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_MultiShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  void *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::MultiShape";
  Procedural::MultiShape *result = 0 ;
  
  if (argc < 1) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Procedural::MultiShape", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      result = (Procedural::MultiShape *)new Procedural::MultiShape(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MultiShape(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_MultiShape__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MultiShape__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      if (argc <= 1) {
        return _wrap_new_MultiShape__SWIG_2(nargs, args, self);
      }
      return _wrap_new_MultiShape__SWIG_2(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MultiShape.new", 
    "    MultiShape.new()\n"
    "    MultiShape.new(Procedural::Shape const &shape)\n"
    "    MultiShape.new(int count, ...)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MultiShape_add_shape(int argc, VALUE *argv, VALUE self) {
  Procedural::MultiShape *arg1 = (Procedural::MultiShape *) 0 ;
  Procedural::Shape *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::MultiShape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MultiShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MultiShape *","addShape", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MultiShape * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__Shape,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::Shape const &","addShape", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::Shape const &","addShape", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::Shape * >(argp2);
  {
    try {
      result = (Procedural::MultiShape *) &(arg1)->addShape((Procedural::Shape const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__MultiShape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MultiShape_get_shape__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MultiShape *arg1 = (Procedural::MultiShape *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MultiShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MultiShape const *","getShape", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MultiShape * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getShape", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::Shape *) &((Procedural::MultiShape const *)arg1)->getShape(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MultiShape_get_shape__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MultiShape *arg1 = (Procedural::MultiShape *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MultiShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MultiShape *","getShape", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MultiShape * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getShape", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::Shape *) &(arg1)->getShape(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MultiShape_get_shape(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MultiShape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MultiShape_get_shape__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MultiShape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MultiShape_get_shape__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "MultiShape.get_shape", 
    "    Procedural::Shape & MultiShape.get_shape(int i)\n"
    "    Procedural::Shape & MultiShape.get_shape(int i)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MultiShape_get_points(int argc, VALUE *argv, VALUE self) {
  Procedural::MultiShape *arg1 = (Procedural::MultiShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< std::vector< Ogre::Vector2,std::allocator< Ogre::Vector2 > > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MultiShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MultiShape const *","getPoints", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MultiShape * >(argp1);
  {
    try {
      result = ((Procedural::MultiShape const *)arg1)->getPoints();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new std::vector< Ogre::Vector2,std::allocator< Ogre::Vector2 > >(static_cast< const std::vector< Ogre::Vector2,std::allocator< Ogre::Vector2 > >& >(result))), SWIGTYPE_p_std__vectorT_Ogre__Vector2_std__allocatorT_Ogre__Vector2_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MultiShape_get_shape_count(int argc, VALUE *argv, VALUE self) {
  Procedural::MultiShape *arg1 = (Procedural::MultiShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MultiShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MultiShape const *","getShapeCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MultiShape * >(argp1);
  {
    try {
      result = (int)((Procedural::MultiShape const *)arg1)->getShapeCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MultiShape_add_multi_shape(int argc, VALUE *argv, VALUE self) {
  Procedural::MultiShape *arg1 = (Procedural::MultiShape *) 0 ;
  Procedural::MultiShape *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MultiShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MultiShape *","addMultiShape", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MultiShape * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__MultiShape,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::MultiShape const &","addMultiShape", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::MultiShape const &","addMultiShape", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::MultiShape * >(argp2);
  {
    try {
      (arg1)->addMultiShape((Procedural::MultiShape const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MultiShape_realize_mesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MultiShape *arg1 = (Procedural::MultiShape *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MultiShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MultiShape *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MultiShape * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MultiShape_realize_mesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MultiShape *arg1 = (Procedural::MultiShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MultiShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MultiShape *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MultiShape * >(argp1);
  {
    try {
      result = (arg1)->realizeMesh();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MultiShape_realize_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MultiShape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MultiShape_realize_mesh__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MultiShape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MultiShape_realize_mesh__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "MultiShape.realize_mesh", 
    "    Ogre::MeshPtr MultiShape.realize_mesh(std::string const &name)\n"
    "    Ogre::MeshPtr MultiShape.realize_mesh()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MultiShape_is_point_inside(int argc, VALUE *argv, VALUE self) {
  Procedural::MultiShape *arg1 = (Procedural::MultiShape *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MultiShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MultiShape const *","isPointInside", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MultiShape * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","isPointInside", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","isPointInside", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  {
    try {
      result = (bool)((Procedural::MultiShape const *)arg1)->isPointInside((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MultiShape_is_closed(int argc, VALUE *argv, VALUE self) {
  Procedural::MultiShape *arg1 = (Procedural::MultiShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MultiShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MultiShape const *","isClosed", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MultiShape * >(argp1);
  {
    try {
      result = (bool)((Procedural::MultiShape const *)arg1)->isClosed();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MultiShape_close(int argc, VALUE *argv, VALUE self) {
  Procedural::MultiShape *arg1 = (Procedural::MultiShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MultiShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MultiShape *","close", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MultiShape * >(argp1);
  {
    try {
      (arg1)->close();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MultiShape_is_outside_real_outside(int argc, VALUE *argv, VALUE self) {
  Procedural::MultiShape *arg1 = (Procedural::MultiShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MultiShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MultiShape const *","isOutsideRealOutside", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MultiShape * >(argp1);
  {
    try {
      result = (bool)((Procedural::MultiShape const *)arg1)->isOutsideRealOutside();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_MultiShape(Procedural::MultiShape *arg1) {
    delete arg1;
}

swig_class SwigClassPlaneMeshGenerator;

SWIGINTERN VALUE
_wrap_PlaneMeshGenerator_realize_mesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::PlaneGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::PlaneGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::PlaneGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::PlaneGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","realizeMesh", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","realizeMesh", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneMeshGenerator_realize_mesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::PlaneGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::PlaneGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::PlaneGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::PlaneGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneMeshGenerator_realize_mesh__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::PlaneGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::PlaneGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::PlaneGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::PlaneGenerator > * >(argp1);
  {
    try {
      result = (arg1)->realizeMesh();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PlaneMeshGenerator_realize_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PlaneMeshGenerator_realize_mesh__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PlaneMeshGenerator_realize_mesh__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PlaneMeshGenerator_realize_mesh__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "PlaneMeshGenerator.realize_mesh", 
    "    Ogre::MeshPtr PlaneMeshGenerator.realize_mesh(std::string const &name, Ogre::String const &group)\n"
    "    Ogre::MeshPtr PlaneMeshGenerator.realize_mesh(std::string const &name)\n"
    "    Ogre::MeshPtr PlaneMeshGenerator.realize_mesh()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneMeshGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::PlaneGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::PlaneGenerator > *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::PlaneGenerator > const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::PlaneGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::MeshGenerator< Procedural::PlaneGenerator > const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneMeshGenerator_set_utile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::PlaneGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::PlaneGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::PlaneGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::PlaneGenerator > *","setUTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::PlaneGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setUTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::PlaneGenerator *) &(arg1)->setUTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneMeshGenerator_set_vtile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::PlaneGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::PlaneGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::PlaneGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::PlaneGenerator > *","setVTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::PlaneGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setVTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::PlaneGenerator *) &(arg1)->setVTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneMeshGenerator_set_texture_rectangle(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::PlaneGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::PlaneGenerator > *) 0 ;
  Ogre::Rectangle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::PlaneGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::PlaneGenerator > *","setTextureRectangle", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::PlaneGenerator > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Rectangle,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rectangle","setTextureRectangle", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rectangle","setTextureRectangle", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Rectangle * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::PlaneGenerator *) &(arg1)->setTextureRectangle(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneMeshGenerator_set_enable_normals(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::PlaneGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::PlaneGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::PlaneGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::PlaneGenerator > *","setEnableNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::PlaneGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setEnableNormals", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::PlaneGenerator *) &(arg1)->setEnableNormals(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneMeshGenerator_set_num_tex_coord_set(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::PlaneGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::PlaneGenerator > *) 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  Procedural::PlaneGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::PlaneGenerator > *","setNumTexCoordSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::PlaneGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned char","setNumTexCoordSet", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned char >(val2);
  {
    try {
      result = (Procedural::PlaneGenerator *) &(arg1)->setNumTexCoordSet(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneMeshGenerator_set_switch_uv(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::PlaneGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::PlaneGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::PlaneGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::PlaneGenerator > *","setSwitchUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::PlaneGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSwitchUV", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::PlaneGenerator *) &(arg1)->setSwitchUV(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneMeshGenerator_set_orientation(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::PlaneGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::PlaneGenerator > *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::PlaneGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::PlaneGenerator > *","setOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::PlaneGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","setOrientation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","setOrientation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  {
    try {
      result = (Procedural::PlaneGenerator *) &(arg1)->setOrientation((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneMeshGenerator_set_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::PlaneGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::PlaneGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::PlaneGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::PlaneGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::PlaneGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setPosition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setPosition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::PlaneGenerator *) &(arg1)->setPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneMeshGenerator_set_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::PlaneGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::PlaneGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::PlaneGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::PlaneGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::PlaneGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::PlaneGenerator *) &(arg1)->setPosition(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PlaneMeshGenerator_set_position(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PlaneMeshGenerator_set_position__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_PlaneMeshGenerator_set_position__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "PlaneMeshGenerator.set_position", 
    "    Procedural::PlaneGenerator & PlaneMeshGenerator.set_position(Ogre::Vector3 const &position)\n"
    "    Procedural::PlaneGenerator & PlaneMeshGenerator.set_position(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneMeshGenerator_set_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::PlaneGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::PlaneGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::PlaneGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::PlaneGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::PlaneGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setScale", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setScale", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::PlaneGenerator *) &(arg1)->setScale((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneMeshGenerator_set_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::PlaneGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::PlaneGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::PlaneGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::PlaneGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::PlaneGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::PlaneGenerator *) &(arg1)->setScale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneMeshGenerator_set_scale__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::PlaneGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::PlaneGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::PlaneGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::PlaneGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::PlaneGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::PlaneGenerator *) &(arg1)->setScale(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PlaneMeshGenerator_set_scale(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PlaneMeshGenerator_set_scale__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PlaneMeshGenerator_set_scale__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_PlaneMeshGenerator_set_scale__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "PlaneMeshGenerator.set_scale", 
    "    Procedural::PlaneGenerator & PlaneMeshGenerator.set_scale(Ogre::Vector3 const &scale)\n"
    "    Procedural::PlaneGenerator & PlaneMeshGenerator.set_scale(Ogre::Real scale)\n"
    "    Procedural::PlaneGenerator & PlaneMeshGenerator.set_scale(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneMeshGenerator_reset_transforms(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::PlaneGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::PlaneGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::PlaneGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::PlaneGenerator > *","resetTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::PlaneGenerator > * >(argp1);
  {
    try {
      result = (Procedural::PlaneGenerator *) &(arg1)->resetTransforms();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneMeshGenerator__set_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::PlaneGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::PlaneGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Procedural::PlaneGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::PlaneGenerator > *","_setDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::PlaneGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","_setDumpToFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","_setDumpToFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Procedural::PlaneGenerator *) &(arg1)->_setDumpToFile((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneMeshGenerator__disable_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::PlaneGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::PlaneGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::PlaneGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::PlaneGenerator > *","_disableDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::PlaneGenerator > * >(argp1);
  {
    try {
      result = (Procedural::PlaneGenerator *) &(arg1)->_disableDumpToFile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_MeshGenerator_Sl_Procedural_PlaneGenerator_Sg_(Procedural::MeshGenerator< Procedural::PlaneGenerator > *arg1) {
    delete arg1;
}

swig_class SwigClassPlaneGenerator;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_PlaneGenerator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_PlaneGenerator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__PlaneGenerator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_PlaneGenerator(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::PlaneGenerator";
  Procedural::PlaneGenerator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::PlaneGenerator *)new Procedural::PlaneGenerator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::PlaneGenerator *arg1 = (Procedural::PlaneGenerator *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::PlaneGenerator const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::PlaneGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::PlaneGenerator const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneGenerator_set_num_seg_x(int argc, VALUE *argv, VALUE self) {
  Procedural::PlaneGenerator *arg1 = (Procedural::PlaneGenerator *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::PlaneGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::PlaneGenerator *","setNumSegX", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::PlaneGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNumSegX", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::PlaneGenerator *) &(arg1)->setNumSegX(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneGenerator_set_num_seg_y(int argc, VALUE *argv, VALUE self) {
  Procedural::PlaneGenerator *arg1 = (Procedural::PlaneGenerator *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::PlaneGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::PlaneGenerator *","setNumSegY", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::PlaneGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNumSegY", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::PlaneGenerator *) &(arg1)->setNumSegY(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneGenerator_set_normal(int argc, VALUE *argv, VALUE self) {
  Procedural::PlaneGenerator *arg1 = (Procedural::PlaneGenerator *) 0 ;
  Ogre::Vector3 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::PlaneGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::PlaneGenerator *","setNormal", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::PlaneGenerator * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3","setNormal", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3","setNormal", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Vector3 * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::PlaneGenerator *) &(arg1)->setNormal(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneGenerator_set_size_x(int argc, VALUE *argv, VALUE self) {
  Procedural::PlaneGenerator *arg1 = (Procedural::PlaneGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::PlaneGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::PlaneGenerator *","setSizeX", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::PlaneGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSizeX", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::PlaneGenerator *) &(arg1)->setSizeX(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneGenerator_set_size_y(int argc, VALUE *argv, VALUE self) {
  Procedural::PlaneGenerator *arg1 = (Procedural::PlaneGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::PlaneGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::PlaneGenerator *","setSizeY", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::PlaneGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSizeY", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::PlaneGenerator *) &(arg1)->setSizeY(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__PlaneGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_PlaneGenerator(Procedural::PlaneGenerator *arg1) {
    delete arg1;
}

swig_class SwigClassRoundedBoxMeshGenerator;

SWIGINTERN VALUE
_wrap_RoundedBoxMeshGenerator_realize_mesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","realizeMesh", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","realizeMesh", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxMeshGenerator_realize_mesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxMeshGenerator_realize_mesh__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > * >(argp1);
  {
    try {
      result = (arg1)->realizeMesh();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RoundedBoxMeshGenerator_realize_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RoundedBoxMeshGenerator_realize_mesh__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RoundedBoxMeshGenerator_realize_mesh__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RoundedBoxMeshGenerator_realize_mesh__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "RoundedBoxMeshGenerator.realize_mesh", 
    "    Ogre::MeshPtr RoundedBoxMeshGenerator.realize_mesh(std::string const &name, Ogre::String const &group)\n"
    "    Ogre::MeshPtr RoundedBoxMeshGenerator.realize_mesh(std::string const &name)\n"
    "    Ogre::MeshPtr RoundedBoxMeshGenerator.realize_mesh()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxMeshGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxMeshGenerator_set_utile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *","setUTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setUTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->setUTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxMeshGenerator_set_vtile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *","setVTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setVTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->setVTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxMeshGenerator_set_texture_rectangle(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *) 0 ;
  Ogre::Rectangle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *","setTextureRectangle", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Rectangle,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rectangle","setTextureRectangle", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rectangle","setTextureRectangle", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Rectangle * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->setTextureRectangle(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxMeshGenerator_set_enable_normals(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *","setEnableNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setEnableNormals", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->setEnableNormals(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxMeshGenerator_set_num_tex_coord_set(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *) 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *","setNumTexCoordSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned char","setNumTexCoordSet", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned char >(val2);
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->setNumTexCoordSet(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxMeshGenerator_set_switch_uv(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *","setSwitchUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSwitchUV", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->setSwitchUV(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxMeshGenerator_set_orientation(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *","setOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","setOrientation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","setOrientation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->setOrientation((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxMeshGenerator_set_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setPosition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setPosition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->setPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxMeshGenerator_set_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->setPosition(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RoundedBoxMeshGenerator_set_position(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RoundedBoxMeshGenerator_set_position__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_RoundedBoxMeshGenerator_set_position__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "RoundedBoxMeshGenerator.set_position", 
    "    Procedural::RoundedBoxGenerator & RoundedBoxMeshGenerator.set_position(Ogre::Vector3 const &position)\n"
    "    Procedural::RoundedBoxGenerator & RoundedBoxMeshGenerator.set_position(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxMeshGenerator_set_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setScale", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setScale", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->setScale((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxMeshGenerator_set_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->setScale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxMeshGenerator_set_scale__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->setScale(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RoundedBoxMeshGenerator_set_scale(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RoundedBoxMeshGenerator_set_scale__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RoundedBoxMeshGenerator_set_scale__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_RoundedBoxMeshGenerator_set_scale__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "RoundedBoxMeshGenerator.set_scale", 
    "    Procedural::RoundedBoxGenerator & RoundedBoxMeshGenerator.set_scale(Ogre::Vector3 const &scale)\n"
    "    Procedural::RoundedBoxGenerator & RoundedBoxMeshGenerator.set_scale(Ogre::Real scale)\n"
    "    Procedural::RoundedBoxGenerator & RoundedBoxMeshGenerator.set_scale(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxMeshGenerator_reset_transforms(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *","resetTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > * >(argp1);
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->resetTransforms();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxMeshGenerator__set_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *","_setDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","_setDumpToFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","_setDumpToFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->_setDumpToFile((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxMeshGenerator__disable_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *","_disableDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > * >(argp1);
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->_disableDumpToFile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_MeshGenerator_Sl_Procedural_RoundedBoxGenerator_Sg_(Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *arg1) {
    delete arg1;
}

swig_class SwigClassRoundedBoxGenerator;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RoundedBoxGenerator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RoundedBoxGenerator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__RoundedBoxGenerator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RoundedBoxGenerator(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::RoundedBoxGenerator";
  Procedural::RoundedBoxGenerator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::RoundedBoxGenerator *)new Procedural::RoundedBoxGenerator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxGenerator_set_size_x(int argc, VALUE *argv, VALUE self) {
  Procedural::RoundedBoxGenerator *arg1 = (Procedural::RoundedBoxGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::RoundedBoxGenerator *","setSizeX", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::RoundedBoxGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSizeX", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->setSizeX(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxGenerator_set_size_y(int argc, VALUE *argv, VALUE self) {
  Procedural::RoundedBoxGenerator *arg1 = (Procedural::RoundedBoxGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::RoundedBoxGenerator *","setSizeY", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::RoundedBoxGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSizeY", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->setSizeY(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxGenerator_set_size_z(int argc, VALUE *argv, VALUE self) {
  Procedural::RoundedBoxGenerator *arg1 = (Procedural::RoundedBoxGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::RoundedBoxGenerator *","setSizeZ", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::RoundedBoxGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSizeZ", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->setSizeZ(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxGenerator_set_num_seg_x(int argc, VALUE *argv, VALUE self) {
  Procedural::RoundedBoxGenerator *arg1 = (Procedural::RoundedBoxGenerator *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::RoundedBoxGenerator *","setNumSegX", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::RoundedBoxGenerator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","setNumSegX", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->setNumSegX(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxGenerator_set_num_seg_y(int argc, VALUE *argv, VALUE self) {
  Procedural::RoundedBoxGenerator *arg1 = (Procedural::RoundedBoxGenerator *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::RoundedBoxGenerator *","setNumSegY", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::RoundedBoxGenerator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","setNumSegY", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->setNumSegY(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxGenerator_set_num_seg_z(int argc, VALUE *argv, VALUE self) {
  Procedural::RoundedBoxGenerator *arg1 = (Procedural::RoundedBoxGenerator *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::RoundedBoxGenerator *","setNumSegZ", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::RoundedBoxGenerator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","setNumSegZ", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->setNumSegZ(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxGenerator_set_chamfer_size(int argc, VALUE *argv, VALUE self) {
  Procedural::RoundedBoxGenerator *arg1 = (Procedural::RoundedBoxGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::RoundedBoxGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::RoundedBoxGenerator *","setChamferSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::RoundedBoxGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setChamferSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::RoundedBoxGenerator *) &(arg1)->setChamferSize(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedBoxGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::RoundedBoxGenerator *arg1 = (Procedural::RoundedBoxGenerator *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__RoundedBoxGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::RoundedBoxGenerator const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::RoundedBoxGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::RoundedBoxGenerator const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_RoundedBoxGenerator(Procedural::RoundedBoxGenerator *arg1) {
    delete arg1;
}

swig_class SwigClassSphereMeshGenerator;

SWIGINTERN VALUE
_wrap_SphereMeshGenerator_realize_mesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::SphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::SphereGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::SphereGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::SphereGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","realizeMesh", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","realizeMesh", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereMeshGenerator_realize_mesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::SphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::SphereGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::SphereGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::SphereGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereMeshGenerator_realize_mesh__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::SphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::SphereGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::SphereGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::SphereGenerator > * >(argp1);
  {
    try {
      result = (arg1)->realizeMesh();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SphereMeshGenerator_realize_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SphereMeshGenerator_realize_mesh__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SphereMeshGenerator_realize_mesh__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SphereMeshGenerator_realize_mesh__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SphereMeshGenerator.realize_mesh", 
    "    Ogre::MeshPtr SphereMeshGenerator.realize_mesh(std::string const &name, Ogre::String const &group)\n"
    "    Ogre::MeshPtr SphereMeshGenerator.realize_mesh(std::string const &name)\n"
    "    Ogre::MeshPtr SphereMeshGenerator.realize_mesh()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereMeshGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::SphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::SphereGenerator > *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::SphereGenerator > const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::SphereGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::MeshGenerator< Procedural::SphereGenerator > const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereMeshGenerator_set_utile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::SphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::SphereGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::SphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::SphereGenerator > *","setUTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::SphereGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setUTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::SphereGenerator *) &(arg1)->setUTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereMeshGenerator_set_vtile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::SphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::SphereGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::SphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::SphereGenerator > *","setVTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::SphereGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setVTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::SphereGenerator *) &(arg1)->setVTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereMeshGenerator_set_texture_rectangle(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::SphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::SphereGenerator > *) 0 ;
  Ogre::Rectangle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::SphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::SphereGenerator > *","setTextureRectangle", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::SphereGenerator > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Rectangle,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rectangle","setTextureRectangle", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rectangle","setTextureRectangle", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Rectangle * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::SphereGenerator *) &(arg1)->setTextureRectangle(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereMeshGenerator_set_enable_normals(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::SphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::SphereGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::SphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::SphereGenerator > *","setEnableNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::SphereGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setEnableNormals", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::SphereGenerator *) &(arg1)->setEnableNormals(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereMeshGenerator_set_num_tex_coord_set(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::SphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::SphereGenerator > *) 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  Procedural::SphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::SphereGenerator > *","setNumTexCoordSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::SphereGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned char","setNumTexCoordSet", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned char >(val2);
  {
    try {
      result = (Procedural::SphereGenerator *) &(arg1)->setNumTexCoordSet(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereMeshGenerator_set_switch_uv(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::SphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::SphereGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::SphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::SphereGenerator > *","setSwitchUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::SphereGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSwitchUV", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::SphereGenerator *) &(arg1)->setSwitchUV(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereMeshGenerator_set_orientation(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::SphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::SphereGenerator > *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::SphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::SphereGenerator > *","setOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::SphereGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","setOrientation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","setOrientation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  {
    try {
      result = (Procedural::SphereGenerator *) &(arg1)->setOrientation((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereMeshGenerator_set_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::SphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::SphereGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::SphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::SphereGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::SphereGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setPosition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setPosition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::SphereGenerator *) &(arg1)->setPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereMeshGenerator_set_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::SphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::SphereGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::SphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::SphereGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::SphereGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::SphereGenerator *) &(arg1)->setPosition(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SphereMeshGenerator_set_position(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SphereMeshGenerator_set_position__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SphereMeshGenerator_set_position__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SphereMeshGenerator.set_position", 
    "    Procedural::SphereGenerator & SphereMeshGenerator.set_position(Ogre::Vector3 const &position)\n"
    "    Procedural::SphereGenerator & SphereMeshGenerator.set_position(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereMeshGenerator_set_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::SphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::SphereGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::SphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::SphereGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::SphereGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setScale", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setScale", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::SphereGenerator *) &(arg1)->setScale((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereMeshGenerator_set_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::SphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::SphereGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::SphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::SphereGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::SphereGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::SphereGenerator *) &(arg1)->setScale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereMeshGenerator_set_scale__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::SphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::SphereGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::SphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::SphereGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::SphereGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::SphereGenerator *) &(arg1)->setScale(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SphereMeshGenerator_set_scale(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SphereMeshGenerator_set_scale__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SphereMeshGenerator_set_scale__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SphereMeshGenerator_set_scale__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SphereMeshGenerator.set_scale", 
    "    Procedural::SphereGenerator & SphereMeshGenerator.set_scale(Ogre::Vector3 const &scale)\n"
    "    Procedural::SphereGenerator & SphereMeshGenerator.set_scale(Ogre::Real scale)\n"
    "    Procedural::SphereGenerator & SphereMeshGenerator.set_scale(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereMeshGenerator_reset_transforms(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::SphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::SphereGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::SphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::SphereGenerator > *","resetTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::SphereGenerator > * >(argp1);
  {
    try {
      result = (Procedural::SphereGenerator *) &(arg1)->resetTransforms();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereMeshGenerator__set_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::SphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::SphereGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Procedural::SphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::SphereGenerator > *","_setDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::SphereGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","_setDumpToFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","_setDumpToFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Procedural::SphereGenerator *) &(arg1)->_setDumpToFile((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereMeshGenerator__disable_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::SphereGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::SphereGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::SphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::SphereGenerator > *","_disableDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::SphereGenerator > * >(argp1);
  {
    try {
      result = (Procedural::SphereGenerator *) &(arg1)->_disableDumpToFile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_MeshGenerator_Sl_Procedural_SphereGenerator_Sg_(Procedural::MeshGenerator< Procedural::SphereGenerator > *arg1) {
    delete arg1;
}

swig_class SwigClassSphereGenerator;

SWIGINTERN VALUE
_wrap_new_SphereGenerator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  int arg2 ;
  int arg3 ;
  float val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::SphereGenerator";
  Procedural::SphereGenerator *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::SphereGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Procedural::SphereGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Procedural::SphereGenerator", 3, argv[2] ));
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (Procedural::SphereGenerator *)new Procedural::SphereGenerator(arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_SphereGenerator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  int arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::SphereGenerator";
  Procedural::SphereGenerator *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::SphereGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Procedural::SphereGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::SphereGenerator *)new Procedural::SphereGenerator(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_SphereGenerator__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::SphereGenerator";
  Procedural::SphereGenerator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::SphereGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  {
    try {
      result = (Procedural::SphereGenerator *)new Procedural::SphereGenerator(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_SphereGenerator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_SphereGenerator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__SphereGenerator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_SphereGenerator__SWIG_3(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::SphereGenerator";
  Procedural::SphereGenerator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::SphereGenerator *)new Procedural::SphereGenerator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SphereGenerator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_SphereGenerator__SWIG_3(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SphereGenerator__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SphereGenerator__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SphereGenerator__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SphereGenerator.new", 
    "    SphereGenerator.new(Ogre::Real radius, int numRings, int numSegments)\n"
    "    SphereGenerator.new(Ogre::Real radius, int numRings)\n"
    "    SphereGenerator.new(Ogre::Real radius)\n"
    "    SphereGenerator.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereGenerator_set_radius(int argc, VALUE *argv, VALUE self) {
  Procedural::SphereGenerator *arg1 = (Procedural::SphereGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::SphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::SphereGenerator *","setRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::SphereGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::SphereGenerator *) &(arg1)->setRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereGenerator_set_num_rings(int argc, VALUE *argv, VALUE self) {
  Procedural::SphereGenerator *arg1 = (Procedural::SphereGenerator *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Procedural::SphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::SphereGenerator *","setNumRings", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::SphereGenerator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","setNumRings", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Procedural::SphereGenerator *) &(arg1)->setNumRings(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereGenerator_set_num_segments(int argc, VALUE *argv, VALUE self) {
  Procedural::SphereGenerator *arg1 = (Procedural::SphereGenerator *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Procedural::SphereGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::SphereGenerator *","setNumSegments", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::SphereGenerator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","setNumSegments", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Procedural::SphereGenerator *) &(arg1)->setNumSegments(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::SphereGenerator *arg1 = (Procedural::SphereGenerator *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__SphereGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::SphereGenerator const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::SphereGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::SphereGenerator const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_SphereGenerator(Procedural::SphereGenerator *arg1) {
    delete arg1;
}

swig_class SwigClassTorusMeshGenerator;

SWIGINTERN VALUE
_wrap_TorusMeshGenerator_realize_mesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","realizeMesh", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","realizeMesh", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusMeshGenerator_realize_mesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusMeshGenerator_realize_mesh__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusGenerator > * >(argp1);
  {
    try {
      result = (arg1)->realizeMesh();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TorusMeshGenerator_realize_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TorusMeshGenerator_realize_mesh__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TorusMeshGenerator_realize_mesh__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TorusMeshGenerator_realize_mesh__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TorusMeshGenerator.realize_mesh", 
    "    Ogre::MeshPtr TorusMeshGenerator.realize_mesh(std::string const &name, Ogre::String const &group)\n"
    "    Ogre::MeshPtr TorusMeshGenerator.realize_mesh(std::string const &name)\n"
    "    Ogre::MeshPtr TorusMeshGenerator.realize_mesh()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusMeshGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusGenerator > *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusGenerator > const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::MeshGenerator< Procedural::TorusGenerator > const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusMeshGenerator_set_utile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::TorusGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusGenerator > *","setUTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setUTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::TorusGenerator *) &(arg1)->setUTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusMeshGenerator_set_vtile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::TorusGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusGenerator > *","setVTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setVTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::TorusGenerator *) &(arg1)->setVTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusMeshGenerator_set_texture_rectangle(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusGenerator > *) 0 ;
  Ogre::Rectangle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::TorusGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusGenerator > *","setTextureRectangle", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusGenerator > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Rectangle,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rectangle","setTextureRectangle", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rectangle","setTextureRectangle", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Rectangle * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::TorusGenerator *) &(arg1)->setTextureRectangle(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusMeshGenerator_set_enable_normals(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::TorusGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusGenerator > *","setEnableNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setEnableNormals", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::TorusGenerator *) &(arg1)->setEnableNormals(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusMeshGenerator_set_num_tex_coord_set(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusGenerator > *) 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  Procedural::TorusGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusGenerator > *","setNumTexCoordSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned char","setNumTexCoordSet", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned char >(val2);
  {
    try {
      result = (Procedural::TorusGenerator *) &(arg1)->setNumTexCoordSet(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusMeshGenerator_set_switch_uv(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::TorusGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusGenerator > *","setSwitchUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSwitchUV", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::TorusGenerator *) &(arg1)->setSwitchUV(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusMeshGenerator_set_orientation(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusGenerator > *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::TorusGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusGenerator > *","setOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","setOrientation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","setOrientation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  {
    try {
      result = (Procedural::TorusGenerator *) &(arg1)->setOrientation((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusMeshGenerator_set_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::TorusGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setPosition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setPosition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::TorusGenerator *) &(arg1)->setPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusMeshGenerator_set_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::TorusGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::TorusGenerator *) &(arg1)->setPosition(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TorusMeshGenerator_set_position(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TorusMeshGenerator_set_position__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TorusMeshGenerator_set_position__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TorusMeshGenerator.set_position", 
    "    Procedural::TorusGenerator & TorusMeshGenerator.set_position(Ogre::Vector3 const &position)\n"
    "    Procedural::TorusGenerator & TorusMeshGenerator.set_position(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusMeshGenerator_set_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::TorusGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setScale", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setScale", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::TorusGenerator *) &(arg1)->setScale((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusMeshGenerator_set_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::TorusGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::TorusGenerator *) &(arg1)->setScale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusMeshGenerator_set_scale__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::TorusGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::TorusGenerator *) &(arg1)->setScale(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TorusMeshGenerator_set_scale(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TorusMeshGenerator_set_scale__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TorusMeshGenerator_set_scale__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TorusMeshGenerator_set_scale__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TorusMeshGenerator.set_scale", 
    "    Procedural::TorusGenerator & TorusMeshGenerator.set_scale(Ogre::Vector3 const &scale)\n"
    "    Procedural::TorusGenerator & TorusMeshGenerator.set_scale(Ogre::Real scale)\n"
    "    Procedural::TorusGenerator & TorusMeshGenerator.set_scale(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusMeshGenerator_reset_transforms(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::TorusGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusGenerator > *","resetTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusGenerator > * >(argp1);
  {
    try {
      result = (Procedural::TorusGenerator *) &(arg1)->resetTransforms();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusMeshGenerator__set_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Procedural::TorusGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusGenerator > *","_setDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","_setDumpToFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","_setDumpToFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Procedural::TorusGenerator *) &(arg1)->_setDumpToFile((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusMeshGenerator__disable_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::TorusGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusGenerator > *","_disableDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusGenerator > * >(argp1);
  {
    try {
      result = (Procedural::TorusGenerator *) &(arg1)->_disableDumpToFile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_MeshGenerator_Sl_Procedural_TorusGenerator_Sg_(Procedural::MeshGenerator< Procedural::TorusGenerator > *arg1) {
    delete arg1;
}

swig_class SwigClassTorusGenerator;

SWIGINTERN VALUE
_wrap_new_TorusGenerator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  int arg3 ;
  int arg4 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::TorusGenerator";
  Procedural::TorusGenerator *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TorusGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TorusGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Procedural::TorusGenerator", 3, argv[2] ));
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","Procedural::TorusGenerator", 4, argv[3] ));
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (Procedural::TorusGenerator *)new Procedural::TorusGenerator(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TorusGenerator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  int arg3 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::TorusGenerator";
  Procedural::TorusGenerator *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TorusGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TorusGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Procedural::TorusGenerator", 3, argv[2] ));
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (Procedural::TorusGenerator *)new Procedural::TorusGenerator(arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TorusGenerator__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::TorusGenerator";
  Procedural::TorusGenerator *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TorusGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TorusGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::TorusGenerator *)new Procedural::TorusGenerator(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TorusGenerator__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::TorusGenerator";
  Procedural::TorusGenerator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TorusGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  {
    try {
      result = (Procedural::TorusGenerator *)new Procedural::TorusGenerator(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TorusGenerator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TorusGenerator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__TorusGenerator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TorusGenerator__SWIG_4(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::TorusGenerator";
  Procedural::TorusGenerator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::TorusGenerator *)new Procedural::TorusGenerator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TorusGenerator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TorusGenerator__SWIG_4(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_TorusGenerator__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TorusGenerator__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_TorusGenerator__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_TorusGenerator__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TorusGenerator.new", 
    "    TorusGenerator.new(Ogre::Real radius, Ogre::Real sectionRadius, int numSegSection, int numSegCircle)\n"
    "    TorusGenerator.new(Ogre::Real radius, Ogre::Real sectionRadius, int numSegSection)\n"
    "    TorusGenerator.new(Ogre::Real radius, Ogre::Real sectionRadius)\n"
    "    TorusGenerator.new(Ogre::Real radius)\n"
    "    TorusGenerator.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::TorusGenerator *arg1 = (Procedural::TorusGenerator *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TorusGenerator const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TorusGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::TorusGenerator const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusGenerator_set_num_seg_section(int argc, VALUE *argv, VALUE self) {
  Procedural::TorusGenerator *arg1 = (Procedural::TorusGenerator *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::TorusGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TorusGenerator *","setNumSegSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TorusGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNumSegSection", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::TorusGenerator *) &(arg1)->setNumSegSection(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusGenerator_set_num_seg_circle(int argc, VALUE *argv, VALUE self) {
  Procedural::TorusGenerator *arg1 = (Procedural::TorusGenerator *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::TorusGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TorusGenerator *","setNumSegCircle", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TorusGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNumSegCircle", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::TorusGenerator *) &(arg1)->setNumSegCircle(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusGenerator_set_radius(int argc, VALUE *argv, VALUE self) {
  Procedural::TorusGenerator *arg1 = (Procedural::TorusGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::TorusGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TorusGenerator *","setRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TorusGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::TorusGenerator *) &(arg1)->setRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusGenerator_set_section_radius(int argc, VALUE *argv, VALUE self) {
  Procedural::TorusGenerator *arg1 = (Procedural::TorusGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::TorusGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TorusGenerator *","setSectionRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TorusGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSectionRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::TorusGenerator *) &(arg1)->setSectionRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_TorusGenerator(Procedural::TorusGenerator *arg1) {
    delete arg1;
}

swig_class SwigClassTorusKnotMeshGenerator;

SWIGINTERN VALUE
_wrap_TorusKnotMeshGenerator_realize_mesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusKnotGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","realizeMesh", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","realizeMesh", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotMeshGenerator_realize_mesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusKnotGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotMeshGenerator_realize_mesh__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusKnotGenerator > * >(argp1);
  {
    try {
      result = (arg1)->realizeMesh();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TorusKnotMeshGenerator_realize_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TorusKnotMeshGenerator_realize_mesh__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TorusKnotMeshGenerator_realize_mesh__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TorusKnotMeshGenerator_realize_mesh__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TorusKnotMeshGenerator.realize_mesh", 
    "    Ogre::MeshPtr TorusKnotMeshGenerator.realize_mesh(std::string const &name, Ogre::String const &group)\n"
    "    Ogre::MeshPtr TorusKnotMeshGenerator.realize_mesh(std::string const &name)\n"
    "    Ogre::MeshPtr TorusKnotMeshGenerator.realize_mesh()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotMeshGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusKnotGenerator > const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusKnotGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::MeshGenerator< Procedural::TorusKnotGenerator > const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotMeshGenerator_set_utile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *","setUTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusKnotGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setUTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->setUTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotMeshGenerator_set_vtile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *","setVTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusKnotGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setVTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->setVTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotMeshGenerator_set_texture_rectangle(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *) 0 ;
  Ogre::Rectangle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *","setTextureRectangle", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusKnotGenerator > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Rectangle,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rectangle","setTextureRectangle", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rectangle","setTextureRectangle", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Rectangle * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->setTextureRectangle(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotMeshGenerator_set_enable_normals(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *","setEnableNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusKnotGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setEnableNormals", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->setEnableNormals(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotMeshGenerator_set_num_tex_coord_set(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *) 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *","setNumTexCoordSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusKnotGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned char","setNumTexCoordSet", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned char >(val2);
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->setNumTexCoordSet(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotMeshGenerator_set_switch_uv(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *","setSwitchUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusKnotGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSwitchUV", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->setSwitchUV(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotMeshGenerator_set_orientation(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *","setOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusKnotGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","setOrientation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","setOrientation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->setOrientation((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotMeshGenerator_set_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusKnotGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setPosition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setPosition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->setPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotMeshGenerator_set_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusKnotGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->setPosition(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TorusKnotMeshGenerator_set_position(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TorusKnotMeshGenerator_set_position__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TorusKnotMeshGenerator_set_position__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TorusKnotMeshGenerator.set_position", 
    "    Procedural::TorusKnotGenerator & TorusKnotMeshGenerator.set_position(Ogre::Vector3 const &position)\n"
    "    Procedural::TorusKnotGenerator & TorusKnotMeshGenerator.set_position(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotMeshGenerator_set_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusKnotGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setScale", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setScale", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->setScale((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotMeshGenerator_set_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusKnotGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->setScale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotMeshGenerator_set_scale__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusKnotGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->setScale(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TorusKnotMeshGenerator_set_scale(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TorusKnotMeshGenerator_set_scale__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TorusKnotMeshGenerator_set_scale__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TorusKnotMeshGenerator_set_scale__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TorusKnotMeshGenerator.set_scale", 
    "    Procedural::TorusKnotGenerator & TorusKnotMeshGenerator.set_scale(Ogre::Vector3 const &scale)\n"
    "    Procedural::TorusKnotGenerator & TorusKnotMeshGenerator.set_scale(Ogre::Real scale)\n"
    "    Procedural::TorusKnotGenerator & TorusKnotMeshGenerator.set_scale(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotMeshGenerator_reset_transforms(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *","resetTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusKnotGenerator > * >(argp1);
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->resetTransforms();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotMeshGenerator__set_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *","_setDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusKnotGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","_setDumpToFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","_setDumpToFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->_setDumpToFile((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotMeshGenerator__disable_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *","_disableDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TorusKnotGenerator > * >(argp1);
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->_disableDumpToFile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_MeshGenerator_Sl_Procedural_TorusKnotGenerator_Sg_(Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *arg1) {
    delete arg1;
}

swig_class SwigClassTorusKnotGenerator;

SWIGINTERN VALUE
_wrap_new_TorusKnotGenerator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::TorusKnotGenerator";
  Procedural::TorusKnotGenerator *result = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TorusKnotGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TorusKnotGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Procedural::TorusKnotGenerator", 3, argv[2] ));
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","Procedural::TorusKnotGenerator", 4, argv[3] ));
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","Procedural::TorusKnotGenerator", 5, argv[4] ));
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "int","Procedural::TorusKnotGenerator", 6, argv[5] ));
  } 
  arg6 = static_cast< int >(val6);
  {
    try {
      result = (Procedural::TorusKnotGenerator *)new Procedural::TorusKnotGenerator(arg1,arg2,arg3,arg4,arg5,arg6);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TorusKnotGenerator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::TorusKnotGenerator";
  Procedural::TorusKnotGenerator *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TorusKnotGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TorusKnotGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Procedural::TorusKnotGenerator", 3, argv[2] ));
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","Procedural::TorusKnotGenerator", 4, argv[3] ));
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","Procedural::TorusKnotGenerator", 5, argv[4] ));
  } 
  arg5 = static_cast< int >(val5);
  {
    try {
      result = (Procedural::TorusKnotGenerator *)new Procedural::TorusKnotGenerator(arg1,arg2,arg3,arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TorusKnotGenerator__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  int arg3 ;
  int arg4 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::TorusKnotGenerator";
  Procedural::TorusKnotGenerator *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TorusKnotGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TorusKnotGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Procedural::TorusKnotGenerator", 3, argv[2] ));
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","Procedural::TorusKnotGenerator", 4, argv[3] ));
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (Procedural::TorusKnotGenerator *)new Procedural::TorusKnotGenerator(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TorusKnotGenerator__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  int arg3 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::TorusKnotGenerator";
  Procedural::TorusKnotGenerator *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TorusKnotGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TorusKnotGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Procedural::TorusKnotGenerator", 3, argv[2] ));
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (Procedural::TorusKnotGenerator *)new Procedural::TorusKnotGenerator(arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TorusKnotGenerator__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::TorusKnotGenerator";
  Procedural::TorusKnotGenerator *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TorusKnotGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TorusKnotGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::TorusKnotGenerator *)new Procedural::TorusKnotGenerator(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TorusKnotGenerator__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::TorusKnotGenerator";
  Procedural::TorusKnotGenerator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TorusKnotGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  {
    try {
      result = (Procedural::TorusKnotGenerator *)new Procedural::TorusKnotGenerator(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TorusKnotGenerator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TorusKnotGenerator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__TorusKnotGenerator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TorusKnotGenerator__SWIG_6(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::TorusKnotGenerator";
  Procedural::TorusKnotGenerator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::TorusKnotGenerator *)new Procedural::TorusKnotGenerator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TorusKnotGenerator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[6];
  int ii;
  
  argc = nargs;
  if (argc > 6) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TorusKnotGenerator__SWIG_6(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_TorusKnotGenerator__SWIG_5(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TorusKnotGenerator__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_TorusKnotGenerator__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_TorusKnotGenerator__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_TorusKnotGenerator__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_TorusKnotGenerator__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "TorusKnotGenerator.new", 
    "    TorusKnotGenerator.new(Ogre::Real radius, Ogre::Real sectionRadius, int p, int q, int numSegSection, int numSegCircle)\n"
    "    TorusKnotGenerator.new(Ogre::Real radius, Ogre::Real sectionRadius, int p, int q, int numSegSection)\n"
    "    TorusKnotGenerator.new(Ogre::Real radius, Ogre::Real sectionRadius, int p, int q)\n"
    "    TorusKnotGenerator.new(Ogre::Real radius, Ogre::Real sectionRadius, int p)\n"
    "    TorusKnotGenerator.new(Ogre::Real radius, Ogre::Real sectionRadius)\n"
    "    TorusKnotGenerator.new(Ogre::Real radius)\n"
    "    TorusKnotGenerator.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::TorusKnotGenerator *arg1 = (Procedural::TorusKnotGenerator *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TorusKnotGenerator const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TorusKnotGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::TorusKnotGenerator const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotGenerator_set_num_seg_section(int argc, VALUE *argv, VALUE self) {
  Procedural::TorusKnotGenerator *arg1 = (Procedural::TorusKnotGenerator *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TorusKnotGenerator *","setNumSegSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TorusKnotGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNumSegSection", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->setNumSegSection(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotGenerator_set_num_seg_circle(int argc, VALUE *argv, VALUE self) {
  Procedural::TorusKnotGenerator *arg1 = (Procedural::TorusKnotGenerator *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TorusKnotGenerator *","setNumSegCircle", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TorusKnotGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNumSegCircle", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->setNumSegCircle(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotGenerator_set_radius(int argc, VALUE *argv, VALUE self) {
  Procedural::TorusKnotGenerator *arg1 = (Procedural::TorusKnotGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TorusKnotGenerator *","setRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TorusKnotGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->setRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotGenerator_set_section_radius(int argc, VALUE *argv, VALUE self) {
  Procedural::TorusKnotGenerator *arg1 = (Procedural::TorusKnotGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TorusKnotGenerator *","setSectionRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TorusKnotGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSectionRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->setSectionRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotGenerator_set_p(int argc, VALUE *argv, VALUE self) {
  Procedural::TorusKnotGenerator *arg1 = (Procedural::TorusKnotGenerator *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TorusKnotGenerator *","setP", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TorusKnotGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setP", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->setP(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TorusKnotGenerator_set_q(int argc, VALUE *argv, VALUE self) {
  Procedural::TorusKnotGenerator *arg1 = (Procedural::TorusKnotGenerator *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::TorusKnotGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TorusKnotGenerator *","setQ", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TorusKnotGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setQ", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::TorusKnotGenerator *) &(arg1)->setQ(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TorusKnotGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_TorusKnotGenerator(Procedural::TorusKnotGenerator *arg1) {
    delete arg1;
}

swig_class SwigClassTubeMeshGenerator;

SWIGINTERN VALUE
_wrap_TubeMeshGenerator_realize_mesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TubeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TubeGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TubeGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TubeGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","realizeMesh", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","realizeMesh", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2,(Ogre::String const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeMeshGenerator_realize_mesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TubeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TubeGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TubeGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TubeGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeMeshGenerator_realize_mesh__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TubeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TubeGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TubeGenerator > *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TubeGenerator > * >(argp1);
  {
    try {
      result = (arg1)->realizeMesh();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TubeMeshGenerator_realize_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TubeMeshGenerator_realize_mesh__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TubeMeshGenerator_realize_mesh__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TubeMeshGenerator_realize_mesh__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TubeMeshGenerator.realize_mesh", 
    "    Ogre::MeshPtr TubeMeshGenerator.realize_mesh(std::string const &name, Ogre::String const &group)\n"
    "    Ogre::MeshPtr TubeMeshGenerator.realize_mesh(std::string const &name)\n"
    "    Ogre::MeshPtr TubeMeshGenerator.realize_mesh()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeMeshGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TubeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TubeGenerator > *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TubeGenerator > const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TubeGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::MeshGenerator< Procedural::TubeGenerator > const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeMeshGenerator_set_utile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TubeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TubeGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::TubeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TubeGenerator > *","setUTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TubeGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setUTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::TubeGenerator *) &(arg1)->setUTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeMeshGenerator_set_vtile(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TubeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TubeGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::TubeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TubeGenerator > *","setVTile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TubeGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setVTile", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::TubeGenerator *) &(arg1)->setVTile(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeMeshGenerator_set_texture_rectangle(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TubeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TubeGenerator > *) 0 ;
  Ogre::Rectangle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::TubeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TubeGenerator > *","setTextureRectangle", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TubeGenerator > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Rectangle,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rectangle","setTextureRectangle", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rectangle","setTextureRectangle", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Rectangle * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::TubeGenerator *) &(arg1)->setTextureRectangle(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeMeshGenerator_set_enable_normals(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TubeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TubeGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::TubeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TubeGenerator > *","setEnableNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TubeGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setEnableNormals", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::TubeGenerator *) &(arg1)->setEnableNormals(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeMeshGenerator_set_num_tex_coord_set(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TubeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TubeGenerator > *) 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  Procedural::TubeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TubeGenerator > *","setNumTexCoordSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TubeGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned char","setNumTexCoordSet", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned char >(val2);
  {
    try {
      result = (Procedural::TubeGenerator *) &(arg1)->setNumTexCoordSet(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeMeshGenerator_set_switch_uv(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TubeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TubeGenerator > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::TubeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TubeGenerator > *","setSwitchUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TubeGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSwitchUV", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::TubeGenerator *) &(arg1)->setSwitchUV(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeMeshGenerator_set_orientation(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TubeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TubeGenerator > *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::TubeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TubeGenerator > *","setOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TubeGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","setOrientation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","setOrientation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  {
    try {
      result = (Procedural::TubeGenerator *) &(arg1)->setOrientation((Ogre::Quaternion const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeMeshGenerator_set_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TubeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TubeGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::TubeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TubeGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TubeGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setPosition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setPosition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::TubeGenerator *) &(arg1)->setPosition((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeMeshGenerator_set_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TubeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TubeGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::TubeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TubeGenerator > *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TubeGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setPosition", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::TubeGenerator *) &(arg1)->setPosition(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TubeMeshGenerator_set_position(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TubeMeshGenerator_set_position__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TubeMeshGenerator_set_position__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TubeMeshGenerator.set_position", 
    "    Procedural::TubeGenerator & TubeMeshGenerator.set_position(Ogre::Vector3 const &position)\n"
    "    Procedural::TubeGenerator & TubeMeshGenerator.set_position(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeMeshGenerator_set_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TubeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TubeGenerator > *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::TubeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TubeGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TubeGenerator > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setScale", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setScale", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::TubeGenerator *) &(arg1)->setScale((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeMeshGenerator_set_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TubeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TubeGenerator > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::TubeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TubeGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TubeGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::TubeGenerator *) &(arg1)->setScale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeMeshGenerator_set_scale__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TubeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TubeGenerator > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::TubeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TubeGenerator > *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TubeGenerator > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setScale", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::TubeGenerator *) &(arg1)->setScale(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TubeMeshGenerator_set_scale(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TubeMeshGenerator_set_scale__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TubeMeshGenerator_set_scale__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TubeMeshGenerator_set_scale__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TubeMeshGenerator.set_scale", 
    "    Procedural::TubeGenerator & TubeMeshGenerator.set_scale(Ogre::Vector3 const &scale)\n"
    "    Procedural::TubeGenerator & TubeMeshGenerator.set_scale(Ogre::Real scale)\n"
    "    Procedural::TubeGenerator & TubeMeshGenerator.set_scale(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeMeshGenerator_reset_transforms(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TubeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TubeGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::TubeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TubeGenerator > *","resetTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TubeGenerator > * >(argp1);
  {
    try {
      result = (Procedural::TubeGenerator *) &(arg1)->resetTransforms();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeMeshGenerator__set_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TubeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TubeGenerator > *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Procedural::TubeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TubeGenerator > *","_setDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TubeGenerator > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","_setDumpToFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","_setDumpToFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (Procedural::TubeGenerator *) &(arg1)->_setDumpToFile((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeMeshGenerator__disable_dump_to_file(int argc, VALUE *argv, VALUE self) {
  Procedural::MeshGenerator< Procedural::TubeGenerator > *arg1 = (Procedural::MeshGenerator< Procedural::TubeGenerator > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::TubeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::MeshGenerator< Procedural::TubeGenerator > *","_disableDumpToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::MeshGenerator< Procedural::TubeGenerator > * >(argp1);
  {
    try {
      result = (Procedural::TubeGenerator *) &(arg1)->_disableDumpToFile();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_MeshGenerator_Sl_Procedural_TubeGenerator_Sg_(Procedural::MeshGenerator< Procedural::TubeGenerator > *arg1) {
    delete arg1;
}

swig_class SwigClassTubeGenerator;

SWIGINTERN VALUE
_wrap_new_TubeGenerator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  int arg4 ;
  int arg5 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::TubeGenerator";
  Procedural::TubeGenerator *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TubeGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TubeGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TubeGenerator", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","Procedural::TubeGenerator", 4, argv[3] ));
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","Procedural::TubeGenerator", 5, argv[4] ));
  } 
  arg5 = static_cast< int >(val5);
  {
    try {
      result = (Procedural::TubeGenerator *)new Procedural::TubeGenerator(arg1,arg2,arg3,arg4,arg5);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TubeGenerator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  int arg4 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::TubeGenerator";
  Procedural::TubeGenerator *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TubeGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TubeGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TubeGenerator", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","Procedural::TubeGenerator", 4, argv[3] ));
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (Procedural::TubeGenerator *)new Procedural::TubeGenerator(arg1,arg2,arg3,arg4);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TubeGenerator__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::TubeGenerator";
  Procedural::TubeGenerator *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TubeGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TubeGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TubeGenerator", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  {
    try {
      result = (Procedural::TubeGenerator *)new Procedural::TubeGenerator(arg1,arg2,arg3);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TubeGenerator__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::TubeGenerator";
  Procedural::TubeGenerator *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TubeGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TubeGenerator", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::TubeGenerator *)new Procedural::TubeGenerator(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TubeGenerator__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::TubeGenerator";
  Procedural::TubeGenerator *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Procedural::TubeGenerator", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  {
    try {
      result = (Procedural::TubeGenerator *)new Procedural::TubeGenerator(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_TubeGenerator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_TubeGenerator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__TubeGenerator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_TubeGenerator__SWIG_5(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::TubeGenerator";
  Procedural::TubeGenerator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::TubeGenerator *)new Procedural::TubeGenerator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TubeGenerator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs;
  if (argc > 5) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_TubeGenerator__SWIG_5(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_TubeGenerator__SWIG_4(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TubeGenerator__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_TubeGenerator__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_TubeGenerator__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_TubeGenerator__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TubeGenerator.new", 
    "    TubeGenerator.new(Ogre::Real outerRadius, Ogre::Real innerRadius, Ogre::Real height, int numSegBase, int numSegHeight)\n"
    "    TubeGenerator.new(Ogre::Real outerRadius, Ogre::Real innerRadius, Ogre::Real height, int numSegBase)\n"
    "    TubeGenerator.new(Ogre::Real outerRadius, Ogre::Real innerRadius, Ogre::Real height)\n"
    "    TubeGenerator.new(Ogre::Real outerRadius, Ogre::Real innerRadius)\n"
    "    TubeGenerator.new(Ogre::Real outerRadius)\n"
    "    TubeGenerator.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeGenerator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::TubeGenerator *arg1 = (Procedural::TubeGenerator *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TubeGenerator const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TubeGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::TubeGenerator const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeGenerator_set_num_seg_base(int argc, VALUE *argv, VALUE self) {
  Procedural::TubeGenerator *arg1 = (Procedural::TubeGenerator *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::TubeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TubeGenerator *","setNumSegBase", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TubeGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNumSegBase", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::TubeGenerator *) &(arg1)->setNumSegBase(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeGenerator_set_num_seg_height(int argc, VALUE *argv, VALUE self) {
  Procedural::TubeGenerator *arg1 = (Procedural::TubeGenerator *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::TubeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TubeGenerator *","setNumSegHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TubeGenerator * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNumSegHeight", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::TubeGenerator *) &(arg1)->setNumSegHeight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeGenerator_set_outer_radius(int argc, VALUE *argv, VALUE self) {
  Procedural::TubeGenerator *arg1 = (Procedural::TubeGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::TubeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TubeGenerator *","setOuterRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TubeGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setOuterRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::TubeGenerator *) &(arg1)->setOuterRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeGenerator_set_inner_radius(int argc, VALUE *argv, VALUE self) {
  Procedural::TubeGenerator *arg1 = (Procedural::TubeGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::TubeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TubeGenerator *","setInnerRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TubeGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setInnerRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::TubeGenerator *) &(arg1)->setInnerRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TubeGenerator_set_height(int argc, VALUE *argv, VALUE self) {
  Procedural::TubeGenerator *arg1 = (Procedural::TubeGenerator *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::TubeGenerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::TubeGenerator *","setHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::TubeGenerator * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setHeight", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::TubeGenerator *) &(arg1)->setHeight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__TubeGenerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_TubeGenerator(Procedural::TubeGenerator *arg1) {
    delete arg1;
}

swig_class SwigClassTrack;

SWIGINTERN VALUE
_wrap_new_Track__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::Track::AddressingMode arg1 ;
  bool arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::Track";
  Procedural::Track *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Procedural::Track::AddressingMode","Procedural::Track", 1, argv[0] ));
  } 
  arg1 = static_cast< Procedural::Track::AddressingMode >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Procedural::Track", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::Track *)new Procedural::Track(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Track__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Track::AddressingMode arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::Track";
  Procedural::Track *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Procedural::Track::AddressingMode","Procedural::Track", 1, argv[0] ));
  } 
  arg1 = static_cast< Procedural::Track::AddressingMode >(val1);
  {
    try {
      result = (Procedural::Track *)new Procedural::Track(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Track_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Track_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__Track);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Track__SWIG_2(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::Track";
  Procedural::Track *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::Track *)new Procedural::Track();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Track(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Track__SWIG_2(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Track__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Track__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Track.new", 
    "    Track.new(Procedural::Track::AddressingMode addressingMode, bool insertPoint)\n"
    "    Track.new(Procedural::Track::AddressingMode addressingMode)\n"
    "    Track.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Track_get_addressing_mode(int argc, VALUE *argv, VALUE self) {
  Procedural::Track *arg1 = (Procedural::Track *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Track::AddressingMode result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Track, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Track const *","getAddressingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Track * >(argp1);
  {
    try {
      result = (Procedural::Track::AddressingMode)((Procedural::Track const *)arg1)->getAddressingMode();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Track_add_key_frame(int argc, VALUE *argv, VALUE self) {
  Procedural::Track *arg1 = (Procedural::Track *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Procedural::Track *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Track, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Track *","addKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Track * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","addKeyFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","addKeyFrame", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  {
    try {
      result = (Procedural::Track *) &(arg1)->addKeyFrame(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Track, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Track_is_insert_point(int argc, VALUE *argv, VALUE self) {
  Procedural::Track *arg1 = (Procedural::Track *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Track, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Track const *","isInsertPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Track * >(argp1);
  {
    try {
      result = (bool)((Procedural::Track const *)arg1)->isInsertPoint();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Track_get_value__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::Track *arg1 = (Procedural::Track *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  Ogre::Real result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Track, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Track const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Track * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getValue", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","getValue", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","getValue", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = (Ogre::Real)((Procedural::Track const *)arg1)->getValue(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Track_get_value__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Track *arg1 = (Procedural::Track *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Real result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Track, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Track const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Track * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getValue", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Ogre::Real)((Procedural::Track const *)arg1)->getValue(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Track_get_value(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Track, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Track_get_value__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Track, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Track_get_value__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Track.get_value", 
    "    Ogre::Real Track.get_value(Ogre::Real absPos, Ogre::Real relPos, unsigned int index)\n"
    "    Ogre::Real Track.get_value(Ogre::Real pos)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Track__get_key_value_before__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::Track *arg1 = (Procedural::Track *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< std::map< Ogre::Real,Ogre::Real,std::less< Ogre::Real >,std::allocator< std::pair< Ogre::Real const,Ogre::Real > > >::const_iterator > result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Track, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Track const *","_getKeyValueBefore", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Track * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","_getKeyValueBefore", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","_getKeyValueBefore", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","_getKeyValueBefore", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = ((Procedural::Track const *)arg1)->_getKeyValueBefore(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new std::map< Ogre::Real,Ogre::Real,std::less< Ogre::Real >,std::allocator< std::pair< Ogre::Real const,Ogre::Real > > >::const_iterator(static_cast< const std::map< Ogre::Real,Ogre::Real,std::less< Ogre::Real >,std::allocator< std::pair< Ogre::Real const,Ogre::Real > > >::const_iterator& >(result))), SWIGTYPE_p_std__mapT_Ogre__Real_Ogre__Real_std__lessT_Ogre__Real_t_std__allocatorT_std__pairT_Ogre__Real_const_Ogre__Real_t_t_t__const_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Track__get_key_value_before__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Track *arg1 = (Procedural::Track *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< std::map< Ogre::Real,Ogre::Real,std::less< Ogre::Real >,std::allocator< std::pair< Ogre::Real const,Ogre::Real > > >::const_iterator > result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Track, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Track const *","_getKeyValueBefore", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Track * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","_getKeyValueBefore", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = ((Procedural::Track const *)arg1)->_getKeyValueBefore(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new std::map< Ogre::Real,Ogre::Real,std::less< Ogre::Real >,std::allocator< std::pair< Ogre::Real const,Ogre::Real > > >::const_iterator(static_cast< const std::map< Ogre::Real,Ogre::Real,std::less< Ogre::Real >,std::allocator< std::pair< Ogre::Real const,Ogre::Real > > >::const_iterator& >(result))), SWIGTYPE_p_std__mapT_Ogre__Real_Ogre__Real_std__lessT_Ogre__Real_t_std__allocatorT_std__pairT_Ogre__Real_const_Ogre__Real_t_t_t__const_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Track__get_key_value_before(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Track, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Track__get_key_value_before__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Track, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Track__get_key_value_before__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Track._get_key_value_before", 
    "    std::map< Ogre::Real,Ogre::Real,std::less< Ogre::Real >,std::allocator< std::pair< Ogre::Real const,Ogre::Real > > >::const_iterator Track._get_key_value_before(Ogre::Real absPos, Ogre::Real relPos, unsigned int index)\n"
    "    std::map< Ogre::Real,Ogre::Real,std::less< Ogre::Real >,std::allocator< std::pair< Ogre::Real const,Ogre::Real > > >::const_iterator Track._get_key_value_before(Ogre::Real pos)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Track__get_key_value_after__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::Track *arg1 = (Procedural::Track *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< std::map< Ogre::Real,Ogre::Real,std::less< Ogre::Real >,std::allocator< std::pair< Ogre::Real const,Ogre::Real > > >::const_iterator > result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Track, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Track const *","_getKeyValueAfter", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Track * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","_getKeyValueAfter", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","_getKeyValueAfter", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","_getKeyValueAfter", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = ((Procedural::Track const *)arg1)->_getKeyValueAfter(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new std::map< Ogre::Real,Ogre::Real,std::less< Ogre::Real >,std::allocator< std::pair< Ogre::Real const,Ogre::Real > > >::const_iterator(static_cast< const std::map< Ogre::Real,Ogre::Real,std::less< Ogre::Real >,std::allocator< std::pair< Ogre::Real const,Ogre::Real > > >::const_iterator& >(result))), SWIGTYPE_p_std__mapT_Ogre__Real_Ogre__Real_std__lessT_Ogre__Real_t_std__allocatorT_std__pairT_Ogre__Real_const_Ogre__Real_t_t_t__const_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Track__get_key_value_after__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Track *arg1 = (Procedural::Track *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< std::map< Ogre::Real,Ogre::Real,std::less< Ogre::Real >,std::allocator< std::pair< Ogre::Real const,Ogre::Real > > >::const_iterator > result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Track, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Track const *","_getKeyValueAfter", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Track * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","_getKeyValueAfter", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = ((Procedural::Track const *)arg1)->_getKeyValueAfter(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new std::map< Ogre::Real,Ogre::Real,std::less< Ogre::Real >,std::allocator< std::pair< Ogre::Real const,Ogre::Real > > >::const_iterator(static_cast< const std::map< Ogre::Real,Ogre::Real,std::less< Ogre::Real >,std::allocator< std::pair< Ogre::Real const,Ogre::Real > > >::const_iterator& >(result))), SWIGTYPE_p_std__mapT_Ogre__Real_Ogre__Real_std__lessT_Ogre__Real_t_std__allocatorT_std__pairT_Ogre__Real_const_Ogre__Real_t_t_t__const_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Track__get_key_value_after(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Track, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Track__get_key_value_after__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Track, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Track__get_key_value_after__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Track._get_key_value_after", 
    "    std::map< Ogre::Real,Ogre::Real,std::less< Ogre::Real >,std::allocator< std::pair< Ogre::Real const,Ogre::Real > > >::const_iterator Track._get_key_value_after(Ogre::Real absPos, Ogre::Real relPos, unsigned int index)\n"
    "    std::map< Ogre::Real,Ogre::Real,std::less< Ogre::Real >,std::allocator< std::pair< Ogre::Real const,Ogre::Real > > >::const_iterator Track._get_key_value_after(Ogre::Real pos)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Track_get_first_value(int argc, VALUE *argv, VALUE self) {
  Procedural::Track *arg1 = (Procedural::Track *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Real result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Track, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Track *","getFirstValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Track * >(argp1);
  {
    try {
      result = (Ogre::Real)(arg1)->getFirstValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Track_get_last_value(int argc, VALUE *argv, VALUE self) {
  Procedural::Track *arg1 = (Procedural::Track *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Real result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Track, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Track *","getLastValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Track * >(argp1);
  {
    try {
      result = (Ogre::Real)(arg1)->getLastValue();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_Track(Procedural::Track *arg1) {
    delete arg1;
}

swig_class SwigClassShape;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Shape_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Shape_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__Shape);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Shape(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::Shape";
  Procedural::Shape *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::Shape *)new Procedural::Shape();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_add_point__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","addPoint", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","addPoint", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  {
    try {
      result = (Procedural::Shape *) &(arg1)->addPoint((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_add_point__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  {
    try {
      result = (Procedural::Shape *) &(arg1)->addPoint(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Shape_add_point(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Shape_add_point__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Shape_add_point__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Shape.add_point", 
    "    Procedural::Shape & Shape.add_point(Ogre::Vector2 const &pt)\n"
    "    Procedural::Shape & Shape.add_point(Ogre::Real x, Ogre::Real y)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_insert_point__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  size_t arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","insertPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","insertPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","insertPoint", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","insertPoint", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::Shape *) &(arg1)->insertPoint(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_insert_point__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  size_t arg2 ;
  Ogre::Vector2 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","insertPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","insertPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","insertPoint", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","insertPoint", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector2 * >(argp3);
  {
    try {
      result = (Procedural::Shape *) &(arg1)->insertPoint(arg2,(Ogre::Vector2 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Shape_insert_point(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Shape_insert_point__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Shape_insert_point__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Shape.insert_point", 
    "    Procedural::Shape & Shape.insert_point(size_t index, Ogre::Real x, Ogre::Real y)\n"
    "    Procedural::Shape & Shape.insert_point(size_t index, Ogre::Vector2 const &pt)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_add_point_rel__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","addPointRel", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","addPointRel", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","addPointRel", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  {
    try {
      result = (Procedural::Shape *) &(arg1)->addPointRel((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_add_point_rel__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","addPointRel", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","addPointRel", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","addPointRel", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  {
    try {
      result = (Procedural::Shape *) &(arg1)->addPointRel(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Shape_add_point_rel(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Shape_add_point_rel__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Shape_add_point_rel__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Shape.add_point_rel", 
    "    Procedural::Shape & Shape.add_point_rel(Ogre::Vector2 const &pt)\n"
    "    Procedural::Shape & Shape.add_point_rel(Ogre::Real x, Ogre::Real y)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_append_shape(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Procedural::Shape *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","appendShape", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__Shape,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::Shape const &","appendShape", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::Shape const &","appendShape", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::Shape * >(argp2);
  {
    try {
      result = (Procedural::Shape *) &(arg1)->appendShape((Procedural::Shape const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_append_shape_rel(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Procedural::Shape *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","appendShapeRel", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__Shape,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::Shape const &","appendShapeRel", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::Shape const &","appendShapeRel", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::Shape * >(argp2);
  {
    try {
      result = (Procedural::Shape *) &(arg1)->appendShapeRel((Procedural::Shape const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_extract_sub_shape(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Procedural::Shape result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","extractSubShape", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","extractSubShape", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","extractSubShape", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (arg1)->extractSubShape(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::Shape(static_cast< const Procedural::Shape& >(result))), SWIGTYPE_p_Procedural__Shape, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_reverse(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","reverse", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    try {
      result = (Procedural::Shape *) &(arg1)->reverse();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_reset(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    try {
      result = (Procedural::Shape *) &(arg1)->reset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_convert_to_path(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Path result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","convertToPath", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    try {
      result = ((Procedural::Shape const *)arg1)->convertToPath();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::Path(static_cast< const Procedural::Path& >(result))), SWIGTYPE_p_Procedural__Path, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_convert_to_track__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Procedural::Track::AddressingMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::Track result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","convertToTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Procedural::Track::AddressingMode","convertToTrack", 2, argv[0] ));
  } 
  arg2 = static_cast< Procedural::Track::AddressingMode >(val2);
  {
    try {
      result = ((Procedural::Shape const *)arg1)->convertToTrack(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::Track(static_cast< const Procedural::Track& >(result))), SWIGTYPE_p_Procedural__Track, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_convert_to_track__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Track result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","convertToTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    try {
      result = ((Procedural::Shape const *)arg1)->convertToTrack();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::Track(static_cast< const Procedural::Track& >(result))), SWIGTYPE_p_Procedural__Track, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Shape_convert_to_track(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Shape_convert_to_track__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Shape_convert_to_track__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Shape.convert_to_track", 
    "    Procedural::Track Shape.convert_to_track(Procedural::Track::AddressingMode addressingMode)\n"
    "    Procedural::Track Shape.convert_to_track()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_get_points(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< std::vector< Ogre::Vector2,std::allocator< Ogre::Vector2 > > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","getPoints", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    try {
      result = ((Procedural::Shape const *)arg1)->getPoints();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new std::vector< Ogre::Vector2,std::allocator< Ogre::Vector2 > >(static_cast< const std::vector< Ogre::Vector2,std::allocator< Ogre::Vector2 > >& >(result))), SWIGTYPE_p_std__vectorT_Ogre__Vector2_std__allocatorT_Ogre__Vector2_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_get_points_reference__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< Ogre::Vector2,std::allocator< Ogre::Vector2 > > *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","getPointsReference", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    try {
      result = (std::vector< Ogre::Vector2,std::allocator< Ogre::Vector2 > > *) &(arg1)->getPointsReference();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Ogre__Vector2_std__allocatorT_Ogre__Vector2_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_get_points_reference__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< Ogre::Vector2,std::allocator< Ogre::Vector2 > > *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","getPointsReference", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    try {
      result = (std::vector< Ogre::Vector2,std::allocator< Ogre::Vector2 > > *) &((Procedural::Shape const *)arg1)->getPointsReference();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Ogre__Vector2_std__allocatorT_Ogre__Vector2_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Shape_get_points_reference(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 2) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Shape_get_points_reference__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Shape_get_points_reference__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Shape.get_points_reference", 
    "    std::vector< Ogre::Vector2,std::allocator< Ogre::Vector2 > > const & Shape.get_points_reference()\n"
    "    std::vector< Ogre::Vector2,std::allocator< Ogre::Vector2 > > const & Shape.get_points_reference()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_get_point(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::Vector2 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","getPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","getPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Ogre::Vector2 *) &((Procedural::Shape const *)arg1)->getPoint(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector2, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_close(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","close", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    try {
      result = (Procedural::Shape *) &(arg1)->close();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_set_out_side(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Procedural::Side arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","setOutSide", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Procedural::Side","setOutSide", 2, argv[0] ));
  } 
  arg2 = static_cast< Procedural::Side >(val2);
  {
    try {
      result = (Procedural::Shape *) &(arg1)->setOutSide(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_get_out_side(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Side result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","getOutSide", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    try {
      result = (Procedural::Side)((Procedural::Shape const *)arg1)->getOutSide();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_switch_side(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","switchSide", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    try {
      result = (Procedural::Shape *) &(arg1)->switchSide();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_get_seg_count(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","getSegCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    try {
      result = ((Procedural::Shape const *)arg1)->getSegCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_is_closed(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","isClosed", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    try {
      result = (bool)((Procedural::Shape const *)arg1)->isClosed();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_get_direction_after(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::Vector2 result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","getDirectionAfter", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","getDirectionAfter", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((Procedural::Shape const *)arg1)->getDirectionAfter(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_get_direction_before(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::Vector2 result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","getDirectionBefore", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","getDirectionBefore", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((Procedural::Shape const *)arg1)->getDirectionBefore(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_get_avg_direction(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::Vector2 result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","getAvgDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","getAvgDirection", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((Procedural::Shape const *)arg1)->getAvgDirection(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_get_normal_after(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::Vector2 result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","getNormalAfter", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","getNormalAfter", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((Procedural::Shape const *)arg1)->getNormalAfter(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_get_normal_before(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::Vector2 result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","getNormalBefore", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","getNormalBefore", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((Procedural::Shape const *)arg1)->getNormalBefore(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_get_avg_normal(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::Vector2 result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","getAvgNormal", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","getAvgNormal", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((Procedural::Shape const *)arg1)->getAvgNormal(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_realize_mesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_realize_mesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    try {
      result = (arg1)->realizeMesh();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Shape_realize_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Shape_realize_mesh__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Shape_realize_mesh__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Shape.realize_mesh", 
    "    Ogre::MeshPtr Shape.realize_mesh(std::string const &name)\n"
    "    Ogre::MeshPtr Shape.realize_mesh()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape__append_to_manual_object(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Ogre::ManualObject *arg2 = (Ogre::ManualObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","_appendToManualObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ManualObject *","_appendToManualObject", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ManualObject * >(argp2);
  {
    try {
      (arg1)->_appendToManualObject(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_is_point_inside(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","isPointInside", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","isPointInside", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","isPointInside", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  {
    try {
      result = (bool)((Procedural::Shape const *)arg1)->isPointInside((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_boolean_intersect(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Procedural::Shape *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::MultiShape result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","booleanIntersect", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__Shape,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::Shape const &","booleanIntersect", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::Shape const &","booleanIntersect", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::Shape * >(argp2);
  {
    try {
      result = ((Procedural::Shape const *)arg1)->booleanIntersect((Procedural::Shape const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::MultiShape(static_cast< const Procedural::MultiShape& >(result))), SWIGTYPE_p_Procedural__MultiShape, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_boolean_union(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Procedural::Shape *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::MultiShape result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","booleanUnion", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__Shape,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::Shape const &","booleanUnion", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::Shape const &","booleanUnion", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::Shape * >(argp2);
  {
    try {
      result = ((Procedural::Shape const *)arg1)->booleanUnion((Procedural::Shape const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::MultiShape(static_cast< const Procedural::MultiShape& >(result))), SWIGTYPE_p_Procedural__MultiShape, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_boolean_difference(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Procedural::Shape *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::MultiShape result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","booleanDifference", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__Shape,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::Shape const &","booleanDifference", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::Shape const &","booleanDifference", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::Shape * >(argp2);
  {
    try {
      result = ((Procedural::Shape const *)arg1)->booleanDifference((Procedural::Shape const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::MultiShape(static_cast< const Procedural::MultiShape& >(result))), SWIGTYPE_p_Procedural__MultiShape, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_find_real_out_side(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Side result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","findRealOutSide", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    try {
      result = (Procedural::Side)((Procedural::Shape const *)arg1)->findRealOutSide();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_is_outside_real_outside(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","isOutsideRealOutside", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    try {
      result = (bool)((Procedural::Shape const *)arg1)->isOutsideRealOutside();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_merge_keys_with_track(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Procedural::Track *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::Shape result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","mergeKeysWithTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__Track,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::Track const &","mergeKeysWithTrack", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::Track const &","mergeKeysWithTrack", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::Track * >(argp2);
  {
    try {
      result = ((Procedural::Shape const *)arg1)->mergeKeysWithTrack((Procedural::Track const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::Shape(static_cast< const Procedural::Shape& >(result))), SWIGTYPE_p_Procedural__Shape, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_translate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","translate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","translate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  {
    try {
      result = (Procedural::Shape *) &(arg1)->translate((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_translate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","translate", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","translate", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  {
    try {
      result = (Procedural::Shape *) &(arg1)->translate(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Shape_translate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Shape_translate__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Shape_translate__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Shape.translate", 
    "    Procedural::Shape & Shape.translate(Ogre::Vector2 const &translation)\n"
    "    Procedural::Shape & Shape.translate(Ogre::Real translationX, Ogre::Real translationY)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_rotate(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Ogre::Radian arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","rotate", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Radian,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Radian","rotate", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian","rotate", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Radian * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::Shape *) &(arg1)->rotate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","scale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","scale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::Shape *) &(arg1)->scale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","scale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","scale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","scale", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  {
    try {
      result = (Procedural::Shape *) &(arg1)->scale(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_scale__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","scale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","scale", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","scale", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  {
    try {
      result = (Procedural::Shape *) &(arg1)->scale((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Shape_scale(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Shape_scale__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Shape_scale__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Shape_scale__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Shape.scale", 
    "    Procedural::Shape & Shape.scale(Ogre::Real amount)\n"
    "    Procedural::Shape & Shape.scale(Ogre::Real scaleX, Ogre::Real scaleY)\n"
    "    Procedural::Shape & Shape.scale(Ogre::Vector2 const &amount)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_reflect(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::Shape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","reflect", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","reflect", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","reflect", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  {
    try {
      result = (Procedural::Shape *) &(arg1)->reflect((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_get_total_length(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Real result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","getTotalLength", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    try {
      result = (Ogre::Real)((Procedural::Shape const *)arg1)->getTotalLength();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_get_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  unsigned int arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Ogre::Vector2 result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","getPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","getPosition", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","getPosition", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  {
    try {
      result = ((Procedural::Shape const *)arg1)->getPosition(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_get_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Vector2 result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","getPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getPosition", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = ((Procedural::Shape const *)arg1)->getPosition(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Shape_get_position(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Shape_get_position__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Shape_get_position__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Shape.get_position", 
    "    Ogre::Vector2 Shape.get_position(unsigned int i, Ogre::Real coord)\n"
    "    Ogre::Vector2 Shape.get_position(Ogre::Real coord)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_find_bounding_radius(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Real result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape const *","findBoundingRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    try {
      result = (Ogre::Real)((Procedural::Shape const *)arg1)->findBoundingRadius();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Shape_thicken(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::MultiShape result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","thicken", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","thicken", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (arg1)->thicken(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::MultiShape(static_cast< const Procedural::MultiShape& >(result))), SWIGTYPE_p_Procedural__MultiShape, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_Shape(Procedural::Shape *arg1) {
    delete arg1;
}

swig_class SwigClassCubicHermiteSpline2;

SWIGINTERN VALUE
_wrap_CubicHermiteSpline2_add_point__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::CubicHermiteSpline2 *arg1 = (Procedural::CubicHermiteSpline2 *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  Ogre::Vector2 *arg3 = 0 ;
  Ogre::Vector2 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Procedural::CubicHermiteSpline2 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CubicHermiteSpline2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CubicHermiteSpline2 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CubicHermiteSpline2 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","addPoint", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","addPoint", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","addPoint", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","addPoint", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector2 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","addPoint", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","addPoint", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector2 * >(argp4);
  {
    try {
      result = (Procedural::CubicHermiteSpline2 *) &(arg1)->addPoint((Ogre::Vector2 const &)*arg2,(Ogre::Vector2 const &)*arg3,(Ogre::Vector2 const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CubicHermiteSpline2, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CubicHermiteSpline2_add_point__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::CubicHermiteSpline2 *arg1 = (Procedural::CubicHermiteSpline2 *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  Ogre::Vector2 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Procedural::CubicHermiteSpline2 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CubicHermiteSpline2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CubicHermiteSpline2 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CubicHermiteSpline2 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","addPoint", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","addPoint", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","addPoint", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","addPoint", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector2 * >(argp3);
  {
    try {
      result = (Procedural::CubicHermiteSpline2 *) &(arg1)->addPoint((Ogre::Vector2 const &)*arg2,(Ogre::Vector2 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CubicHermiteSpline2, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CubicHermiteSpline2_add_point__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::CubicHermiteSpline2 *arg1 = (Procedural::CubicHermiteSpline2 *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  Procedural::CubicHermiteSplineAutoTangentMode arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Procedural::CubicHermiteSpline2 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CubicHermiteSpline2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CubicHermiteSpline2 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CubicHermiteSpline2 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","addPoint", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","addPoint", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Procedural::CubicHermiteSplineAutoTangentMode","addPoint", 3, argv[1] ));
  } 
  arg3 = static_cast< Procedural::CubicHermiteSplineAutoTangentMode >(val3);
  {
    try {
      result = (Procedural::CubicHermiteSpline2 *) &(arg1)->addPoint((Ogre::Vector2 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CubicHermiteSpline2, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CubicHermiteSpline2_add_point__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Procedural::CubicHermiteSpline2 *arg1 = (Procedural::CubicHermiteSpline2 *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::CubicHermiteSpline2 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CubicHermiteSpline2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CubicHermiteSpline2 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CubicHermiteSpline2 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","addPoint", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","addPoint", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  {
    try {
      result = (Procedural::CubicHermiteSpline2 *) &(arg1)->addPoint((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CubicHermiteSpline2, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CubicHermiteSpline2_add_point__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Procedural::CubicHermiteSpline2 *arg1 = (Procedural::CubicHermiteSpline2 *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Procedural::CubicHermiteSplineAutoTangentMode arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Procedural::CubicHermiteSpline2 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CubicHermiteSpline2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CubicHermiteSpline2 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CubicHermiteSpline2 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Procedural::CubicHermiteSplineAutoTangentMode","addPoint", 4, argv[2] ));
  } 
  arg4 = static_cast< Procedural::CubicHermiteSplineAutoTangentMode >(val4);
  {
    try {
      result = (Procedural::CubicHermiteSpline2 *) &(arg1)->addPoint(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CubicHermiteSpline2, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CubicHermiteSpline2_add_point__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Procedural::CubicHermiteSpline2 *arg1 = (Procedural::CubicHermiteSpline2 *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Procedural::CubicHermiteSpline2 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CubicHermiteSpline2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CubicHermiteSpline2 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CubicHermiteSpline2 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  {
    try {
      result = (Procedural::CubicHermiteSpline2 *) &(arg1)->addPoint(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CubicHermiteSpline2, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CubicHermiteSpline2_add_point(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__CubicHermiteSpline2, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CubicHermiteSpline2_add_point__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__CubicHermiteSpline2, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CubicHermiteSpline2_add_point__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__CubicHermiteSpline2, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CubicHermiteSpline2_add_point__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__CubicHermiteSpline2, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CubicHermiteSpline2_add_point__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__CubicHermiteSpline2, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CubicHermiteSpline2_add_point__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__CubicHermiteSpline2, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_CubicHermiteSpline2_add_point__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "CubicHermiteSpline2.add_point", 
    "    Procedural::CubicHermiteSpline2 & CubicHermiteSpline2.add_point(Ogre::Vector2 const &p, Ogre::Vector2 const &before, Ogre::Vector2 const &after)\n"
    "    Procedural::CubicHermiteSpline2 & CubicHermiteSpline2.add_point(Ogre::Vector2 const &p, Ogre::Vector2 const &tangent)\n"
    "    Procedural::CubicHermiteSpline2 & CubicHermiteSpline2.add_point(Ogre::Vector2 const &p, Procedural::CubicHermiteSplineAutoTangentMode autoTangentMode)\n"
    "    Procedural::CubicHermiteSpline2 & CubicHermiteSpline2.add_point(Ogre::Vector2 const &p)\n"
    "    Procedural::CubicHermiteSpline2 & CubicHermiteSpline2.add_point(Ogre::Real x, Ogre::Real y, Procedural::CubicHermiteSplineAutoTangentMode autoTangentMode)\n"
    "    Procedural::CubicHermiteSpline2 & CubicHermiteSpline2.add_point(Ogre::Real x, Ogre::Real y)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CubicHermiteSpline2_realize_shape(int argc, VALUE *argv, VALUE self) {
  Procedural::CubicHermiteSpline2 *arg1 = (Procedural::CubicHermiteSpline2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Shape result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CubicHermiteSpline2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CubicHermiteSpline2 *","realizeShape", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CubicHermiteSpline2 * >(argp1);
  {
    try {
      result = (arg1)->realizeShape();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::Shape(static_cast< const Procedural::Shape& >(result))), SWIGTYPE_p_Procedural__Shape, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CubicHermiteSpline2_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CubicHermiteSpline2_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__CubicHermiteSpline2);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CubicHermiteSpline2(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::CubicHermiteSpline2";
  Procedural::CubicHermiteSpline2 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::CubicHermiteSpline2 *)new Procedural::CubicHermiteSpline2();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_CubicHermiteSpline2(Procedural::CubicHermiteSpline2 *arg1) {
    delete arg1;
}

swig_class SwigClassCatmullRomSpline2;

SWIGINTERN VALUE
_wrap_CatmullRomSpline2_add_point__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::CatmullRomSpline2 *arg1 = (Procedural::CatmullRomSpline2 *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::CatmullRomSpline2 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CatmullRomSpline2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CatmullRomSpline2 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CatmullRomSpline2 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","addPoint", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","addPoint", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  {
    try {
      result = (Procedural::CatmullRomSpline2 *) &(arg1)->addPoint((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CatmullRomSpline2, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CatmullRomSpline2_add_point__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::CatmullRomSpline2 *arg1 = (Procedural::CatmullRomSpline2 *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Procedural::CatmullRomSpline2 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CatmullRomSpline2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CatmullRomSpline2 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CatmullRomSpline2 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  {
    try {
      result = (Procedural::CatmullRomSpline2 *) &(arg1)->addPoint(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CatmullRomSpline2, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CatmullRomSpline2_add_point(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__CatmullRomSpline2, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CatmullRomSpline2_add_point__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__CatmullRomSpline2, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CatmullRomSpline2_add_point__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "CatmullRomSpline2.add_point", 
    "    Procedural::CatmullRomSpline2 & CatmullRomSpline2.add_point(Ogre::Vector2 const &pt)\n"
    "    Procedural::CatmullRomSpline2 & CatmullRomSpline2.add_point(Ogre::Real x, Ogre::Real y)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CatmullRomSpline2_realize_shape(int argc, VALUE *argv, VALUE self) {
  Procedural::CatmullRomSpline2 *arg1 = (Procedural::CatmullRomSpline2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Shape result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CatmullRomSpline2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CatmullRomSpline2 *","realizeShape", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CatmullRomSpline2 * >(argp1);
  {
    try {
      result = (arg1)->realizeShape();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::Shape(static_cast< const Procedural::Shape& >(result))), SWIGTYPE_p_Procedural__Shape, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CatmullRomSpline2_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CatmullRomSpline2_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__CatmullRomSpline2);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CatmullRomSpline2(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::CatmullRomSpline2";
  Procedural::CatmullRomSpline2 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::CatmullRomSpline2 *)new Procedural::CatmullRomSpline2();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_CatmullRomSpline2(Procedural::CatmullRomSpline2 *arg1) {
    delete arg1;
}

swig_class SwigClassKochanekBartelsSpline2;

SWIGINTERN VALUE
_wrap_KochanekBartelsSpline2_add_point__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::KochanekBartelsSpline2 *arg1 = (Procedural::KochanekBartelsSpline2 *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Procedural::KochanekBartelsSpline2 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__KochanekBartelsSpline2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::KochanekBartelsSpline2 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::KochanekBartelsSpline2 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  {
    try {
      result = (Procedural::KochanekBartelsSpline2 *) &(arg1)->addPoint(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__KochanekBartelsSpline2, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_KochanekBartelsSpline2_add_point__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::KochanekBartelsSpline2 *arg1 = (Procedural::KochanekBartelsSpline2 *) 0 ;
  Ogre::Vector2 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::KochanekBartelsSpline2 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__KochanekBartelsSpline2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::KochanekBartelsSpline2 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::KochanekBartelsSpline2 * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2","addPoint", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2","addPoint", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Vector2 * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::KochanekBartelsSpline2 *) &(arg1)->addPoint(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__KochanekBartelsSpline2, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_KochanekBartelsSpline2_add_point__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::KochanekBartelsSpline2 *arg1 = (Procedural::KochanekBartelsSpline2 *) 0 ;
  Ogre::Vector2 arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  Procedural::KochanekBartelsSpline2 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__KochanekBartelsSpline2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::KochanekBartelsSpline2 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::KochanekBartelsSpline2 * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2","addPoint", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2","addPoint", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Vector2 * >(argp2));
    }
  }
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  {
    try {
      result = (Procedural::KochanekBartelsSpline2 *) &(arg1)->addPoint(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__KochanekBartelsSpline2, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_KochanekBartelsSpline2_add_point(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[6];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 6) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__KochanekBartelsSpline2, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KochanekBartelsSpline2_add_point__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__KochanekBartelsSpline2, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_KochanekBartelsSpline2_add_point__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__KochanekBartelsSpline2, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_KochanekBartelsSpline2_add_point__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "KochanekBartelsSpline2.add_point", 
    "    Procedural::KochanekBartelsSpline2 & KochanekBartelsSpline2.add_point(Ogre::Real x, Ogre::Real y)\n"
    "    Procedural::KochanekBartelsSpline2 & KochanekBartelsSpline2.add_point(Ogre::Vector2 p)\n"
    "    Procedural::KochanekBartelsSpline2 & KochanekBartelsSpline2.add_point(Ogre::Vector2 p, Ogre::Real t, Ogre::Real b, Ogre::Real c)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_KochanekBartelsSpline2_realize_shape(int argc, VALUE *argv, VALUE self) {
  Procedural::KochanekBartelsSpline2 *arg1 = (Procedural::KochanekBartelsSpline2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Shape result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__KochanekBartelsSpline2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::KochanekBartelsSpline2 *","realizeShape", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::KochanekBartelsSpline2 * >(argp1);
  {
    try {
      result = (arg1)->realizeShape();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::Shape(static_cast< const Procedural::Shape& >(result))), SWIGTYPE_p_Procedural__Shape, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_KochanekBartelsSpline2_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_KochanekBartelsSpline2_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__KochanekBartelsSpline2);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_KochanekBartelsSpline2(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::KochanekBartelsSpline2";
  Procedural::KochanekBartelsSpline2 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::KochanekBartelsSpline2 *)new Procedural::KochanekBartelsSpline2();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_KochanekBartelsSpline2(Procedural::KochanekBartelsSpline2 *arg1) {
    delete arg1;
}

swig_class SwigClassRectangleShape;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RectangleShape_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RectangleShape_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__RectangleShape);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RectangleShape(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::RectangleShape";
  Procedural::RectangleShape *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::RectangleShape *)new Procedural::RectangleShape();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RectangleShape_set_width(int argc, VALUE *argv, VALUE self) {
  Procedural::RectangleShape *arg1 = (Procedural::RectangleShape *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::RectangleShape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__RectangleShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::RectangleShape *","setWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::RectangleShape * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setWidth", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::RectangleShape *) &(arg1)->setWidth(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RectangleShape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RectangleShape_set_height(int argc, VALUE *argv, VALUE self) {
  Procedural::RectangleShape *arg1 = (Procedural::RectangleShape *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::RectangleShape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__RectangleShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::RectangleShape *","setHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::RectangleShape * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setHeight", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::RectangleShape *) &(arg1)->setHeight(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RectangleShape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RectangleShape_realize_shape(int argc, VALUE *argv, VALUE self) {
  Procedural::RectangleShape *arg1 = (Procedural::RectangleShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Shape result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__RectangleShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::RectangleShape *","realizeShape", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::RectangleShape * >(argp1);
  {
    try {
      result = (arg1)->realizeShape();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::Shape(static_cast< const Procedural::Shape& >(result))), SWIGTYPE_p_Procedural__Shape, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_RectangleShape(Procedural::RectangleShape *arg1) {
    delete arg1;
}

swig_class SwigClassCircleShape;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CircleShape_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CircleShape_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__CircleShape);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CircleShape(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::CircleShape";
  Procedural::CircleShape *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::CircleShape *)new Procedural::CircleShape();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CircleShape_set_radius(int argc, VALUE *argv, VALUE self) {
  Procedural::CircleShape *arg1 = (Procedural::CircleShape *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::CircleShape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CircleShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CircleShape *","setRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CircleShape * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::CircleShape *) &(arg1)->setRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CircleShape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CircleShape_set_num_seg(int argc, VALUE *argv, VALUE self) {
  Procedural::CircleShape *arg1 = (Procedural::CircleShape *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Procedural::CircleShape *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CircleShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CircleShape *","setNumSeg", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CircleShape * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","setNumSeg", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Procedural::CircleShape *) &(arg1)->setNumSeg(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CircleShape, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CircleShape_realize_shape(int argc, VALUE *argv, VALUE self) {
  Procedural::CircleShape *arg1 = (Procedural::CircleShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Shape result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CircleShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CircleShape *","realizeShape", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CircleShape * >(argp1);
  {
    try {
      result = (arg1)->realizeShape();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::Shape(static_cast< const Procedural::Shape& >(result))), SWIGTYPE_p_Procedural__Shape, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_CircleShape(Procedural::CircleShape *arg1) {
    delete arg1;
}

swig_class SwigClassRoundedCornerSpline2;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RoundedCornerSpline2_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RoundedCornerSpline2_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__RoundedCornerSpline2);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RoundedCornerSpline2(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::RoundedCornerSpline2";
  Procedural::RoundedCornerSpline2 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::RoundedCornerSpline2 *)new Procedural::RoundedCornerSpline2();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedCornerSpline2_set_radius(int argc, VALUE *argv, VALUE self) {
  Procedural::RoundedCornerSpline2 *arg1 = (Procedural::RoundedCornerSpline2 *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::RoundedCornerSpline2 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__RoundedCornerSpline2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::RoundedCornerSpline2 *","setRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::RoundedCornerSpline2 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::RoundedCornerSpline2 *) &(arg1)->setRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedCornerSpline2, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedCornerSpline2_add_point__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::RoundedCornerSpline2 *arg1 = (Procedural::RoundedCornerSpline2 *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::RoundedCornerSpline2 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__RoundedCornerSpline2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::RoundedCornerSpline2 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::RoundedCornerSpline2 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","addPoint", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","addPoint", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  {
    try {
      result = (Procedural::RoundedCornerSpline2 *) &(arg1)->addPoint((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedCornerSpline2, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedCornerSpline2_add_point__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::RoundedCornerSpline2 *arg1 = (Procedural::RoundedCornerSpline2 *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Procedural::RoundedCornerSpline2 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__RoundedCornerSpline2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::RoundedCornerSpline2 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::RoundedCornerSpline2 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  {
    try {
      result = (Procedural::RoundedCornerSpline2 *) &(arg1)->addPoint(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedCornerSpline2, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RoundedCornerSpline2_add_point(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__RoundedCornerSpline2, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RoundedCornerSpline2_add_point__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__RoundedCornerSpline2, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RoundedCornerSpline2_add_point__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "RoundedCornerSpline2.add_point", 
    "    Procedural::RoundedCornerSpline2 & RoundedCornerSpline2.add_point(Ogre::Vector2 const &p)\n"
    "    Procedural::RoundedCornerSpline2 & RoundedCornerSpline2.add_point(Ogre::Real x, Ogre::Real y)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedCornerSpline2_realize_shape(int argc, VALUE *argv, VALUE self) {
  Procedural::RoundedCornerSpline2 *arg1 = (Procedural::RoundedCornerSpline2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Shape result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__RoundedCornerSpline2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::RoundedCornerSpline2 *","realizeShape", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::RoundedCornerSpline2 * >(argp1);
  {
    try {
      result = (arg1)->realizeShape();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::Shape(static_cast< const Procedural::Shape& >(result))), SWIGTYPE_p_Procedural__Shape, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_RoundedCornerSpline2(Procedural::RoundedCornerSpline2 *arg1) {
    delete arg1;
}

swig_class SwigClassCircle;

SWIGINTERN VALUE
_wrap_Circle_is_point_inside(int argc, VALUE *argv, VALUE self) {
  Procedural::Circle *arg1 = (Procedural::Circle *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Circle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Circle const *","isPointInside", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Circle * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","isPointInside", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","isPointInside", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  {
    try {
      result = (bool)((Procedural::Circle const *)arg1)->isPointInside((Ogre::Vector2 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_Circle(Procedural::Circle *arg1) {
    delete arg1;
}

swig_class SwigClassPlane;

SWIGINTERN VALUE
_wrap_new_Plane__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::Plane";
  Procedural::Plane *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::Plane *)new Procedural::Plane();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Plane_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Plane_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__Plane);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Plane__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::Plane";
  Procedural::Plane *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Procedural::Plane", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Procedural::Plane", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Procedural::Plane", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Procedural::Plane", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::Plane *)new Procedural::Plane((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Plane(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Plane__SWIG_0(nargs, args, self);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Plane__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Plane.new", 
    "    Plane.new()\n"
    "    Plane.new(Ogre::Vector3 const &normal, Ogre::Vector3 const &pos)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Procedural_Plane(Procedural::Plane *arg1) {
    delete arg1;
}

swig_class SwigClassLine;

SWIGINTERN VALUE
_wrap_new_Line__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::Line";
  Procedural::Line *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::Line *)new Procedural::Line();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Line_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Line_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__Line);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Line__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 arg1 ;
  Ogre::Vector3 arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::Line";
  Procedural::Line *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector3,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3","Procedural::Line", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3","Procedural::Line", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::Vector3 * >(argp1));
    }
  }
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3","Procedural::Line", 2, argv[1] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3","Procedural::Line", 2, argv[1]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Vector3 * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::Line *)new Procedural::Line(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Line(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Line__SWIG_0(nargs, args, self);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Line__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Line.new", 
    "    Line.new()\n"
    "    Line.new(Ogre::Vector3 point, Ogre::Vector3 direction)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Line_set_from_2points(int argc, VALUE *argv, VALUE self) {
  Procedural::Line *arg1 = (Procedural::Line *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Line, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Line *","setFrom2Points", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Line * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setFrom2Points", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setFrom2Points", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setFrom2Points", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setFrom2Points", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  {
    try {
      (arg1)->setFrom2Points((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_Line(Procedural::Line *arg1) {
    delete arg1;
}

swig_class SwigClassLine2D;

SWIGINTERN VALUE
_wrap_new_Line2D__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::Line2D";
  Procedural::Line2D *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::Line2D *)new Procedural::Line2D();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Line2D_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Line2D_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__Line2D);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Line2D__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 arg1 ;
  Ogre::Vector2 arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::Line2D";
  Procedural::Line2D *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector2,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2","Procedural::Line2D", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2","Procedural::Line2D", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::Vector2 * >(argp1));
    }
  }
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2","Procedural::Line2D", 2, argv[1] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2","Procedural::Line2D", 2, argv[1]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Vector2 * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::Line2D *)new Procedural::Line2D(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Line2D(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Line2D__SWIG_0(nargs, args, self);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Line2D__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Line2D.new", 
    "    Line2D.new()\n"
    "    Line2D.new(Ogre::Vector2 point, Ogre::Vector2 direction)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Line2D_set_from_2points(int argc, VALUE *argv, VALUE self) {
  Procedural::Line2D *arg1 = (Procedural::Line2D *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  Ogre::Vector2 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Line2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Line2D *","setFrom2Points", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Line2D * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","setFrom2Points", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","setFrom2Points", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","setFrom2Points", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","setFrom2Points", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector2 * >(argp3);
  {
    try {
      (arg1)->setFrom2Points((Ogre::Vector2 const &)*arg2,(Ogre::Vector2 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_Line2D(Procedural::Line2D *arg1) {
    delete arg1;
}

swig_class SwigClassSegment2D;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Segment2D_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Segment2D_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__Segment2D);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Segment2D(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 arg1 ;
  Ogre::Vector2 arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::Segment2D";
  Procedural::Segment2D *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector2,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2","Procedural::Segment2D", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2","Procedural::Segment2D", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::Vector2 * >(argp1));
    }
  }
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Vector2,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2","Procedural::Segment2D", 2, argv[1] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2","Procedural::Segment2D", 2, argv[1]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Vector2 * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::Segment2D *)new Procedural::Segment2D(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Segment2D_get_a(int argc, VALUE *argv, VALUE self) {
  Procedural::Segment2D *arg1 = (Procedural::Segment2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Vector2 result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Segment2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Segment2D *","getA", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Segment2D * >(argp1);
  {
    try {
      result = (arg1)->getA();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Segment2D_get_b(int argc, VALUE *argv, VALUE self) {
  Procedural::Segment2D *arg1 = (Procedural::Segment2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Vector2 result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Segment2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Segment2D *","getB", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Segment2D * >(argp1);
  {
    try {
      result = (arg1)->getB();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_Segment2D(Procedural::Segment2D *arg1) {
    delete arg1;
}

swig_class SwigClassLathe;

SWIGINTERN VALUE
_wrap_new_Lathe__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::Lathe";
  Procedural::Lathe *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","Procedural::Lathe", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Procedural::Lathe", 2, argv[1] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::Lathe *)new Procedural::Lathe(arg1,arg2);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Lathe__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Shape *arg1 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::Lathe";
  Procedural::Lathe *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Shape *","Procedural::Lathe", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Procedural::Shape * >(argp1);
  {
    try {
      result = (Procedural::Lathe *)new Procedural::Lathe(arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Lathe_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Lathe_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__Lathe);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Lathe__SWIG_2(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::Lathe";
  Procedural::Lathe *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::Lathe *)new Procedural::Lathe();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Lathe(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Lathe__SWIG_2(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Lathe__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Shape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Lathe__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Lathe.new", 
    "    Lathe.new(Procedural::Shape *shapeToExtrude, int numSeg)\n"
    "    Lathe.new(Procedural::Shape *shapeToExtrude)\n"
    "    Lathe.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Lathe_set_num_seg(int argc, VALUE *argv, VALUE self) {
  Procedural::Lathe *arg1 = (Procedural::Lathe *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Procedural::Lathe *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Lathe, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Lathe *","setNumSeg", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Lathe * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNumSeg", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Procedural::Lathe *) &(arg1)->setNumSeg(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Lathe, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Lathe_set_angle_begin(int argc, VALUE *argv, VALUE self) {
  Procedural::Lathe *arg1 = (Procedural::Lathe *) 0 ;
  Ogre::Radian arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::Lathe *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Lathe, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Lathe *","setAngleBegin", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Lathe * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Radian,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Radian","setAngleBegin", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian","setAngleBegin", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Radian * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::Lathe *) &(arg1)->setAngleBegin(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Lathe, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Lathe_set_angle_end(int argc, VALUE *argv, VALUE self) {
  Procedural::Lathe *arg1 = (Procedural::Lathe *) 0 ;
  Ogre::Radian arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::Lathe *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Lathe, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Lathe *","setAngleEnd", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Lathe * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Radian,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Radian","setAngleEnd", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian","setAngleEnd", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Radian * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::Lathe *) &(arg1)->setAngleEnd(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Lathe, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Lathe_set_closed(int argc, VALUE *argv, VALUE self) {
  Procedural::Lathe *arg1 = (Procedural::Lathe *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::Lathe *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Lathe, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Lathe *","setClosed", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Lathe * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setClosed", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::Lathe *) &(arg1)->setClosed(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Lathe, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Lathe_set_capped(int argc, VALUE *argv, VALUE self) {
  Procedural::Lathe *arg1 = (Procedural::Lathe *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::Lathe *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Lathe, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Lathe *","setCapped", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Lathe * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setCapped", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::Lathe *) &(arg1)->setCapped(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Lathe, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Lathe_set_shape_to_extrude(int argc, VALUE *argv, VALUE self) {
  Procedural::Lathe *arg1 = (Procedural::Lathe *) 0 ;
  Procedural::Shape *arg2 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Procedural::Lathe *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Lathe, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Lathe *","setShapeToExtrude", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Lathe * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::Shape *","setShapeToExtrude", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Procedural::Shape * >(argp2);
  {
    try {
      result = (Procedural::Lathe *) &(arg1)->setShapeToExtrude(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Lathe, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Lathe_set_multi_shape_to_extrude(int argc, VALUE *argv, VALUE self) {
  Procedural::Lathe *arg1 = (Procedural::Lathe *) 0 ;
  Procedural::MultiShape *arg2 = (Procedural::MultiShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Procedural::Lathe *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Lathe, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Lathe *","setMultiShapeToExtrude", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Lathe * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Procedural__MultiShape, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::MultiShape *","setMultiShapeToExtrude", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Procedural::MultiShape * >(argp2);
  {
    try {
      result = (Procedural::Lathe *) &(arg1)->setMultiShapeToExtrude(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Lathe, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Lathe_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::Lathe *arg1 = (Procedural::Lathe *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Lathe, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Lathe const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Lathe * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::Lathe const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_Lathe(Procedural::Lathe *arg1) {
    delete arg1;
}

swig_class SwigClassPath;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Path_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Path_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__Path);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Path(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::Path";
  Procedural::Path *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::Path *)new Procedural::Path();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_add_point__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::Path *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","addPoint", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addPoint", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::Path *) &(arg1)->addPoint((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Path, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_add_point__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::Path *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::Path *) &(arg1)->addPoint(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Path, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Path_add_point(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Path, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Path_add_point__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Path, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Path_add_point__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Path.add_point", 
    "    Procedural::Path & Path.add_point(Ogre::Vector3 const &pt)\n"
    "    Procedural::Path & Path.add_point(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_insert_point__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  size_t arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  Procedural::Path *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","insertPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","insertPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","insertPoint", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","insertPoint", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","insertPoint", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  {
    try {
      result = (Procedural::Path *) &(arg1)->insertPoint(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Path, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_insert_point__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  size_t arg2 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Procedural::Path *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","insertPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","insertPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","insertPoint", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","insertPoint", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  {
    try {
      result = (Procedural::Path *) &(arg1)->insertPoint(arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Path, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Path_insert_point(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[6];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 6) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Path, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Path_insert_point__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Path, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Path_insert_point__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Path.insert_point", 
    "    Procedural::Path & Path.insert_point(size_t index, Ogre::Real x, Ogre::Real y, Ogre::Real z)\n"
    "    Procedural::Path & Path.insert_point(size_t index, Ogre::Vector3 const &pt)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_append_path(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  Procedural::Path *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::Path *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","appendPath", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__Path,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::Path const &","appendPath", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::Path const &","appendPath", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::Path * >(argp2);
  {
    try {
      result = (Procedural::Path *) &(arg1)->appendPath((Procedural::Path const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Path, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_append_path_rel(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  Procedural::Path *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::Path *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","appendPathRel", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__Path,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::Path const &","appendPathRel", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::Path const &","appendPathRel", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::Path * >(argp2);
  {
    try {
      result = (Procedural::Path *) &(arg1)->appendPathRel((Procedural::Path const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Path, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_reset(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Path *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  {
    try {
      result = (Procedural::Path *) &(arg1)->reset();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Path, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_close(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Path *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","close", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  {
    try {
      result = (Procedural::Path *) &(arg1)->close();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Path, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_is_closed(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","isClosed", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  {
    try {
      result = (bool)(arg1)->isClosed();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_get_points(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< std::vector< Ogre::Vector3,std::allocator< Ogre::Vector3 > > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","getPoints", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  {
    try {
      result = (arg1)->getPoints();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new std::vector< Ogre::Vector3,std::allocator< Ogre::Vector3 > >(static_cast< const std::vector< Ogre::Vector3,std::allocator< Ogre::Vector3 > >& >(result))), SWIGTYPE_p_std__vectorT_Ogre__Vector3_std__allocatorT_Ogre__Vector3_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_get_points_reference(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< Ogre::Vector3,std::allocator< Ogre::Vector3 > > *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","getPointsReference", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  {
    try {
      result = (std::vector< Ogre::Vector3,std::allocator< Ogre::Vector3 > > *) &(arg1)->getPointsReference();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Ogre__Vector3_std__allocatorT_Ogre__Vector3_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_get_point(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Ogre::Vector3 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path const *","getPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (Ogre::Vector3 *) &((Procedural::Path const *)arg1)->getPoint(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_get_seg_count(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","getSegCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  {
    try {
      result = (int)(arg1)->getSegCount();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_get_direction_after(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::Vector3 result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","getDirectionAfter", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","getDirectionAfter", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (arg1)->getDirectionAfter(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_get_direction_before(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::Vector3 result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","getDirectionBefore", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","getDirectionBefore", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (arg1)->getDirectionBefore(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_get_avg_direction(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::Vector3 result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","getAvgDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","getAvgDirection", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (arg1)->getAvgDirection(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_get_total_length(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Real result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path const *","getTotalLength", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  {
    try {
      result = (Ogre::Real)((Procedural::Path const *)arg1)->getTotalLength();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_get_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  unsigned int arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Ogre::Vector3 result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path const *","getPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","getPosition", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","getPosition", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  {
    try {
      result = ((Procedural::Path const *)arg1)->getPosition(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_get_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Vector3 result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path const *","getPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getPosition", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = ((Procedural::Path const *)arg1)->getPosition(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Path_get_position(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Path, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Path_get_position__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Path, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Path_get_position__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Path.get_position", 
    "    Ogre::Vector3 Path.get_position(unsigned int i, Ogre::Real coord)\n"
    "    Ogre::Vector3 Path.get_position(Ogre::Real coord)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_realize_mesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","realizeMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","realizeMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->realizeMesh((std::string const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_realize_mesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","realizeMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  {
    try {
      result = (arg1)->realizeMesh();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::MeshPtr(static_cast< const Ogre::MeshPtr& >(result))), SWIGTYPE_p_Ogre__MeshPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Path_realize_mesh(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Path, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Path_realize_mesh__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Path, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Path_realize_mesh__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Path.realize_mesh", 
    "    Ogre::MeshPtr Path.realize_mesh(std::string const &name)\n"
    "    Ogre::MeshPtr Path.realize_mesh()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_merge_keys_with_track(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  Procedural::Track *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::Path result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path const *","mergeKeysWithTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__Track,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::Track const &","mergeKeysWithTrack", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::Track const &","mergeKeysWithTrack", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::Track * >(argp2);
  {
    try {
      result = ((Procedural::Path const *)arg1)->mergeKeysWithTrack((Procedural::Track const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::Path(static_cast< const Procedural::Path& >(result))), SWIGTYPE_p_Procedural__Path, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_translate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::Path *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","translate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","translate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::Path *) &(arg1)->translate((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Path, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_translate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::Path *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","translate", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","translate", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","translate", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::Path *) &(arg1)->translate(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Path, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Path_translate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Path, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Path_translate__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Path, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Path_translate__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Path.translate", 
    "    Procedural::Path & Path.translate(Ogre::Vector3 const &translation)\n"
    "    Procedural::Path & Path.translate(Ogre::Real translationX, Ogre::Real translationY, Ogre::Real translationZ)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::Path *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","scale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","scale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::Path *) &(arg1)->scale(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Path, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::Path *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","scale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","scale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","scale", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","scale", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::Path *) &(arg1)->scale(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Path, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_scale__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::Path *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","scale", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","scale", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","scale", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::Path *) &(arg1)->scale((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Path, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Path_scale(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Path, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Path_scale__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Path, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Path_scale__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__Path, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Path_scale__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Path.scale", 
    "    Procedural::Path & Path.scale(Ogre::Real amount)\n"
    "    Procedural::Path & Path.scale(Ogre::Real scaleX, Ogre::Real scaleY, Ogre::Real scaleZ)\n"
    "    Procedural::Path & Path.scale(Ogre::Vector3 const &amount)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_reflect(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::Path *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","reflect", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","reflect", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","reflect", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::Path *) &(arg1)->reflect((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Path, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_extract_sub_path(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Procedural::Path result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","extractSubPath", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","extractSubPath", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","extractSubPath", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (arg1)->extractSubPath(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::Path(static_cast< const Procedural::Path& >(result))), SWIGTYPE_p_Procedural__Path, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Path_reverse(int argc, VALUE *argv, VALUE self) {
  Procedural::Path *arg1 = (Procedural::Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Path *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Path *","reverse", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Path * >(argp1);
  {
    try {
      result = (Procedural::Path *) &(arg1)->reverse();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Path, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_Path(Procedural::Path *arg1) {
    delete arg1;
}

swig_class SwigClassCatmullRomSpline3;

SWIGINTERN VALUE
_wrap_new_CatmullRomSpline3__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::CatmullRomSpline3";
  Procedural::CatmullRomSpline3 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::CatmullRomSpline3 *)new Procedural::CatmullRomSpline3();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CatmullRomSpline3_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CatmullRomSpline3_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__CatmullRomSpline3);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CatmullRomSpline3__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleSpline *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Procedural::CatmullRomSpline3";
  Procedural::CatmullRomSpline3 *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__SimpleSpline,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleSpline const &","Procedural::CatmullRomSpline3", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::SimpleSpline const &","Procedural::CatmullRomSpline3", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleSpline * >(argp1);
  {
    try {
      result = (Procedural::CatmullRomSpline3 *)new Procedural::CatmullRomSpline3((Ogre::SimpleSpline const &)*arg1);
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CatmullRomSpline3(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_CatmullRomSpline3__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SimpleSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CatmullRomSpline3__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CatmullRomSpline3.new", 
    "    CatmullRomSpline3.new()\n"
    "    CatmullRomSpline3.new(Ogre::SimpleSpline const &input)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CatmullRomSpline3_to_simple_spline(int argc, VALUE *argv, VALUE self) {
  Procedural::CatmullRomSpline3 *arg1 = (Procedural::CatmullRomSpline3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SimpleSpline result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CatmullRomSpline3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CatmullRomSpline3 const *","toSimpleSpline", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CatmullRomSpline3 * >(argp1);
  {
    try {
      result = ((Procedural::CatmullRomSpline3 const *)arg1)->toSimpleSpline();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Ogre::SimpleSpline(static_cast< const Ogre::SimpleSpline& >(result))), SWIGTYPE_p_Ogre__SimpleSpline, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CatmullRomSpline3_add_point__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::CatmullRomSpline3 *arg1 = (Procedural::CatmullRomSpline3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::CatmullRomSpline3 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CatmullRomSpline3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CatmullRomSpline3 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CatmullRomSpline3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","addPoint", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addPoint", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::CatmullRomSpline3 *) &(arg1)->addPoint((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CatmullRomSpline3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CatmullRomSpline3_add_point__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::CatmullRomSpline3 *arg1 = (Procedural::CatmullRomSpline3 *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::CatmullRomSpline3 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CatmullRomSpline3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CatmullRomSpline3 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CatmullRomSpline3 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::CatmullRomSpline3 *) &(arg1)->addPoint(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CatmullRomSpline3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CatmullRomSpline3_add_point(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__CatmullRomSpline3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CatmullRomSpline3_add_point__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__CatmullRomSpline3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_CatmullRomSpline3_add_point__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "CatmullRomSpline3.add_point", 
    "    Procedural::CatmullRomSpline3 & CatmullRomSpline3.add_point(Ogre::Vector3 const &pt)\n"
    "    Procedural::CatmullRomSpline3 & CatmullRomSpline3.add_point(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CatmullRomSpline3_realize_path(int argc, VALUE *argv, VALUE self) {
  Procedural::CatmullRomSpline3 *arg1 = (Procedural::CatmullRomSpline3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Path result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CatmullRomSpline3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CatmullRomSpline3 *","realizePath", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CatmullRomSpline3 * >(argp1);
  {
    try {
      result = (arg1)->realizePath();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::Path(static_cast< const Procedural::Path& >(result))), SWIGTYPE_p_Procedural__Path, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_CatmullRomSpline3(Procedural::CatmullRomSpline3 *arg1) {
    delete arg1;
}

swig_class SwigClassCubicHermiteSpline3;

SWIGINTERN VALUE
_wrap_CubicHermiteSpline3_add_point__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::CubicHermiteSpline3 *arg1 = (Procedural::CubicHermiteSpline3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Vector3 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Procedural::CubicHermiteSpline3 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CubicHermiteSpline3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CubicHermiteSpline3 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CubicHermiteSpline3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","addPoint", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addPoint", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","addPoint", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addPoint", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","addPoint", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addPoint", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  {
    try {
      result = (Procedural::CubicHermiteSpline3 *) &(arg1)->addPoint((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CubicHermiteSpline3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CubicHermiteSpline3_add_point__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::CubicHermiteSpline3 *arg1 = (Procedural::CubicHermiteSpline3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Procedural::CubicHermiteSpline3 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CubicHermiteSpline3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CubicHermiteSpline3 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CubicHermiteSpline3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","addPoint", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addPoint", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","addPoint", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addPoint", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  {
    try {
      result = (Procedural::CubicHermiteSpline3 *) &(arg1)->addPoint((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CubicHermiteSpline3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CubicHermiteSpline3_add_point__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Procedural::CubicHermiteSpline3 *arg1 = (Procedural::CubicHermiteSpline3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Procedural::CubicHermiteSplineAutoTangentMode arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Procedural::CubicHermiteSpline3 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CubicHermiteSpline3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CubicHermiteSpline3 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CubicHermiteSpline3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","addPoint", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addPoint", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Procedural::CubicHermiteSplineAutoTangentMode","addPoint", 3, argv[1] ));
  } 
  arg3 = static_cast< Procedural::CubicHermiteSplineAutoTangentMode >(val3);
  {
    try {
      result = (Procedural::CubicHermiteSpline3 *) &(arg1)->addPoint((Ogre::Vector3 const &)*arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CubicHermiteSpline3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CubicHermiteSpline3_add_point__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Procedural::CubicHermiteSpline3 *arg1 = (Procedural::CubicHermiteSpline3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::CubicHermiteSpline3 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CubicHermiteSpline3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CubicHermiteSpline3 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CubicHermiteSpline3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","addPoint", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addPoint", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::CubicHermiteSpline3 *) &(arg1)->addPoint((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CubicHermiteSpline3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CubicHermiteSpline3_add_point__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Procedural::CubicHermiteSpline3 *arg1 = (Procedural::CubicHermiteSpline3 *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Procedural::CubicHermiteSplineAutoTangentMode arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Procedural::CubicHermiteSpline3 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CubicHermiteSpline3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CubicHermiteSpline3 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CubicHermiteSpline3 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Procedural::CubicHermiteSplineAutoTangentMode","addPoint", 5, argv[3] ));
  } 
  arg5 = static_cast< Procedural::CubicHermiteSplineAutoTangentMode >(val5);
  {
    try {
      result = (Procedural::CubicHermiteSpline3 *) &(arg1)->addPoint(arg2,arg3,arg4,arg5);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CubicHermiteSpline3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CubicHermiteSpline3_add_point__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Procedural::CubicHermiteSpline3 *arg1 = (Procedural::CubicHermiteSpline3 *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::CubicHermiteSpline3 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CubicHermiteSpline3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CubicHermiteSpline3 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CubicHermiteSpline3 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::CubicHermiteSpline3 *) &(arg1)->addPoint(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__CubicHermiteSpline3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CubicHermiteSpline3_add_point(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[6];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 6) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__CubicHermiteSpline3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CubicHermiteSpline3_add_point__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__CubicHermiteSpline3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CubicHermiteSpline3_add_point__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__CubicHermiteSpline3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CubicHermiteSpline3_add_point__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__CubicHermiteSpline3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CubicHermiteSpline3_add_point__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__CubicHermiteSpline3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_CubicHermiteSpline3_add_point__SWIG_5(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__CubicHermiteSpline3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_CubicHermiteSpline3_add_point__SWIG_4(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "CubicHermiteSpline3.add_point", 
    "    Procedural::CubicHermiteSpline3 & CubicHermiteSpline3.add_point(Ogre::Vector3 const &p, Ogre::Vector3 const &before, Ogre::Vector3 const &after)\n"
    "    Procedural::CubicHermiteSpline3 & CubicHermiteSpline3.add_point(Ogre::Vector3 const &p, Ogre::Vector3 const &tangent)\n"
    "    Procedural::CubicHermiteSpline3 & CubicHermiteSpline3.add_point(Ogre::Vector3 const &p, Procedural::CubicHermiteSplineAutoTangentMode autoTangentMode)\n"
    "    Procedural::CubicHermiteSpline3 & CubicHermiteSpline3.add_point(Ogre::Vector3 const &p)\n"
    "    Procedural::CubicHermiteSpline3 & CubicHermiteSpline3.add_point(Ogre::Real x, Ogre::Real y, Ogre::Real z, Procedural::CubicHermiteSplineAutoTangentMode autoTangentMode)\n"
    "    Procedural::CubicHermiteSpline3 & CubicHermiteSpline3.add_point(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CubicHermiteSpline3_realize_path(int argc, VALUE *argv, VALUE self) {
  Procedural::CubicHermiteSpline3 *arg1 = (Procedural::CubicHermiteSpline3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Path result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__CubicHermiteSpline3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::CubicHermiteSpline3 *","realizePath", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::CubicHermiteSpline3 * >(argp1);
  {
    try {
      result = (arg1)->realizePath();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::Path(static_cast< const Procedural::Path& >(result))), SWIGTYPE_p_Procedural__Path, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_CubicHermiteSpline3_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_CubicHermiteSpline3_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__CubicHermiteSpline3);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_CubicHermiteSpline3(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::CubicHermiteSpline3";
  Procedural::CubicHermiteSpline3 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::CubicHermiteSpline3 *)new Procedural::CubicHermiteSpline3();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_CubicHermiteSpline3(Procedural::CubicHermiteSpline3 *arg1) {
    delete arg1;
}

swig_class SwigClassLinePath;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_LinePath_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_LinePath_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__LinePath);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_LinePath(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::LinePath";
  Procedural::LinePath *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::LinePath *)new Procedural::LinePath();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LinePath_set_point1(int argc, VALUE *argv, VALUE self) {
  Procedural::LinePath *arg1 = (Procedural::LinePath *) 0 ;
  Ogre::Vector3 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::LinePath *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__LinePath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::LinePath *","setPoint1", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::LinePath * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3","setPoint1", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3","setPoint1", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Vector3 * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::LinePath *) &(arg1)->setPoint1(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__LinePath, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LinePath_set_point2(int argc, VALUE *argv, VALUE self) {
  Procedural::LinePath *arg1 = (Procedural::LinePath *) 0 ;
  Ogre::Vector3 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::LinePath *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__LinePath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::LinePath *","setPoint2", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::LinePath * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3","setPoint2", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3","setPoint2", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Vector3 * >(argp2));
    }
  }
  {
    try {
      result = (Procedural::LinePath *) &(arg1)->setPoint2(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__LinePath, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LinePath_set_num_seg(int argc, VALUE *argv, VALUE self) {
  Procedural::LinePath *arg1 = (Procedural::LinePath *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Procedural::LinePath *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__LinePath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::LinePath *","setNumSeg", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::LinePath * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","setNumSeg", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (Procedural::LinePath *) &(arg1)->setNumSeg(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__LinePath, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LinePath_between_points(int argc, VALUE *argv, VALUE self) {
  Procedural::LinePath *arg1 = (Procedural::LinePath *) 0 ;
  Ogre::Vector3 arg2 ;
  Ogre::Vector3 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Procedural::LinePath *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__LinePath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::LinePath *","betweenPoints", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::LinePath * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3","betweenPoints", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3","betweenPoints", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Vector3 * >(argp2));
    }
  }
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Vector3,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3","betweenPoints", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3","betweenPoints", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< Ogre::Vector3 * >(argp3));
    }
  }
  {
    try {
      result = (Procedural::LinePath *) &(arg1)->betweenPoints(arg2,arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__LinePath, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LinePath_realize_path(int argc, VALUE *argv, VALUE self) {
  Procedural::LinePath *arg1 = (Procedural::LinePath *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Path result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__LinePath, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::LinePath *","realizePath", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::LinePath * >(argp1);
  {
    try {
      result = (arg1)->realizePath();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::Path(static_cast< const Procedural::Path& >(result))), SWIGTYPE_p_Procedural__Path, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_LinePath(Procedural::LinePath *arg1) {
    delete arg1;
}

swig_class SwigClassRoundedCornerSpline3;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_RoundedCornerSpline3_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_RoundedCornerSpline3_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__RoundedCornerSpline3);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_RoundedCornerSpline3(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::RoundedCornerSpline3";
  Procedural::RoundedCornerSpline3 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::RoundedCornerSpline3 *)new Procedural::RoundedCornerSpline3();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedCornerSpline3_set_radius(int argc, VALUE *argv, VALUE self) {
  Procedural::RoundedCornerSpline3 *arg1 = (Procedural::RoundedCornerSpline3 *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Procedural::RoundedCornerSpline3 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__RoundedCornerSpline3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::RoundedCornerSpline3 *","setRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::RoundedCornerSpline3 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    try {
      result = (Procedural::RoundedCornerSpline3 *) &(arg1)->setRadius(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedCornerSpline3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedCornerSpline3_add_point__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Procedural::RoundedCornerSpline3 *arg1 = (Procedural::RoundedCornerSpline3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Procedural::RoundedCornerSpline3 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__RoundedCornerSpline3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::RoundedCornerSpline3 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::RoundedCornerSpline3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","addPoint", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addPoint", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  {
    try {
      result = (Procedural::RoundedCornerSpline3 *) &(arg1)->addPoint((Ogre::Vector3 const &)*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedCornerSpline3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedCornerSpline3_add_point__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Procedural::RoundedCornerSpline3 *arg1 = (Procedural::RoundedCornerSpline3 *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Procedural::RoundedCornerSpline3 *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__RoundedCornerSpline3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::RoundedCornerSpline3 *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::RoundedCornerSpline3 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","addPoint", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  {
    try {
      result = (Procedural::RoundedCornerSpline3 *) &(arg1)->addPoint(arg2,arg3,arg4);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__RoundedCornerSpline3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RoundedCornerSpline3_add_point(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__RoundedCornerSpline3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RoundedCornerSpline3_add_point__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Procedural__RoundedCornerSpline3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_RoundedCornerSpline3_add_point__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "RoundedCornerSpline3.add_point", 
    "    Procedural::RoundedCornerSpline3 & RoundedCornerSpline3.add_point(Ogre::Vector3 const &p)\n"
    "    Procedural::RoundedCornerSpline3 & RoundedCornerSpline3.add_point(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RoundedCornerSpline3_realize_path(int argc, VALUE *argv, VALUE self) {
  Procedural::RoundedCornerSpline3 *arg1 = (Procedural::RoundedCornerSpline3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Procedural::Path result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__RoundedCornerSpline3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::RoundedCornerSpline3 *","realizePath", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::RoundedCornerSpline3 * >(argp1);
  {
    try {
      result = (arg1)->realizePath();
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj((new Procedural::Path(static_cast< const Procedural::Path& >(result))), SWIGTYPE_p_Procedural__Path, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_RoundedCornerSpline3(Procedural::RoundedCornerSpline3 *arg1) {
    delete arg1;
}

swig_class SwigClassExtruder;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Extruder_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Extruder_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__Extruder);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Extruder(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::Extruder";
  Procedural::Extruder *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::Extruder *)new Procedural::Extruder();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Extruder_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::Extruder *arg1 = (Procedural::Extruder *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Extruder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Extruder const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Extruder * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::Extruder const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Extruder_set_shape_to_extrude(int argc, VALUE *argv, VALUE self) {
  Procedural::Extruder *arg1 = (Procedural::Extruder *) 0 ;
  Procedural::Shape *arg2 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Procedural::Extruder *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Extruder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Extruder *","setShapeToExtrude", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Extruder * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::Shape *","setShapeToExtrude", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Procedural::Shape * >(argp2);
  {
    try {
      result = (Procedural::Extruder *) &(arg1)->setShapeToExtrude(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Extruder, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Extruder_set_multi_shape_to_extrude(int argc, VALUE *argv, VALUE self) {
  Procedural::Extruder *arg1 = (Procedural::Extruder *) 0 ;
  Procedural::MultiShape *arg2 = (Procedural::MultiShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Procedural::Extruder *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Extruder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Extruder *","setMultiShapeToExtrude", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Extruder * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Procedural__MultiShape, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::MultiShape *","setMultiShapeToExtrude", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Procedural::MultiShape * >(argp2);
  {
    try {
      result = (Procedural::Extruder *) &(arg1)->setMultiShapeToExtrude(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Extruder, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Extruder_set_extrusion_path(int argc, VALUE *argv, VALUE self) {
  Procedural::Extruder *arg1 = (Procedural::Extruder *) 0 ;
  Procedural::Path *arg2 = (Procedural::Path *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Procedural::Extruder *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Extruder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Extruder *","setExtrusionPath", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Extruder * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Procedural__Path, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::Path *","setExtrusionPath", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Procedural::Path * >(argp2);
  {
    try {
      result = (Procedural::Extruder *) &(arg1)->setExtrusionPath(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Extruder, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Extruder_set_rotation_track(int argc, VALUE *argv, VALUE self) {
  Procedural::Extruder *arg1 = (Procedural::Extruder *) 0 ;
  Procedural::Track *arg2 = (Procedural::Track *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Procedural::Extruder *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Extruder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Extruder *","setRotationTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Extruder * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Procedural__Track, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::Track *","setRotationTrack", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Procedural::Track * >(argp2);
  {
    try {
      result = (Procedural::Extruder *) &(arg1)->setRotationTrack(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Extruder, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Extruder_set_scale_track(int argc, VALUE *argv, VALUE self) {
  Procedural::Extruder *arg1 = (Procedural::Extruder *) 0 ;
  Procedural::Track *arg2 = (Procedural::Track *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Procedural::Extruder *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Extruder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Extruder *","setScaleTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Extruder * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Procedural__Track, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::Track *","setScaleTrack", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Procedural::Track * >(argp2);
  {
    try {
      result = (Procedural::Extruder *) &(arg1)->setScaleTrack(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Extruder, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Extruder_set_shape_texture_track(int argc, VALUE *argv, VALUE self) {
  Procedural::Extruder *arg1 = (Procedural::Extruder *) 0 ;
  Procedural::Track *arg2 = (Procedural::Track *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Procedural::Extruder *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Extruder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Extruder *","setShapeTextureTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Extruder * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Procedural__Track, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::Track *","setShapeTextureTrack", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Procedural::Track * >(argp2);
  {
    try {
      result = (Procedural::Extruder *) &(arg1)->setShapeTextureTrack(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Extruder, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Extruder_set_path_texture_track(int argc, VALUE *argv, VALUE self) {
  Procedural::Extruder *arg1 = (Procedural::Extruder *) 0 ;
  Procedural::Track *arg2 = (Procedural::Track *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Procedural::Extruder *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Extruder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Extruder *","setPathTextureTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Extruder * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Procedural__Track, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::Track *","setPathTextureTrack", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Procedural::Track * >(argp2);
  {
    try {
      result = (Procedural::Extruder *) &(arg1)->setPathTextureTrack(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Extruder, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Extruder_set_capped(int argc, VALUE *argv, VALUE self) {
  Procedural::Extruder *arg1 = (Procedural::Extruder *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Procedural::Extruder *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Extruder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Extruder *","setCapped", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Extruder * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setCapped", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (Procedural::Extruder *) &(arg1)->setCapped(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Extruder, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_Extruder(Procedural::Extruder *arg1) {
    delete arg1;
}

swig_class SwigClassTriangulator;

#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
SWIGINTERN VALUE
_wrap_Triangulator_allocate(VALUE self) {
#else
  SWIGINTERN VALUE
  _wrap_Triangulator_allocate(int argc, VALUE *argv, VALUE self) {
#endif
    
    
    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Procedural__Triangulator);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Triangulator(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Procedural::Triangulator";
  Procedural::Triangulator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (Procedural::Triangulator *)new Procedural::Triangulator();
      DATA_PTR(self) = result;
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Triangulator_set_shape_to_triangulate(int argc, VALUE *argv, VALUE self) {
  Procedural::Triangulator *arg1 = (Procedural::Triangulator *) 0 ;
  Procedural::Shape *arg2 = (Procedural::Shape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Procedural::Triangulator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Triangulator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Triangulator *","setShapeToTriangulate", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Triangulator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Procedural__Shape, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::Shape *","setShapeToTriangulate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Procedural::Shape * >(argp2);
  {
    try {
      result = (Procedural::Triangulator *) &(arg1)->setShapeToTriangulate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Triangulator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Triangulator_set_multi_shape_to_triangulate(int argc, VALUE *argv, VALUE self) {
  Procedural::Triangulator *arg1 = (Procedural::Triangulator *) 0 ;
  Procedural::MultiShape *arg2 = (Procedural::MultiShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Procedural::Triangulator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Triangulator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Triangulator *","setMultiShapeToTriangulate", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Triangulator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Procedural__MultiShape, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::MultiShape *","setMultiShapeToTriangulate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Procedural::MultiShape * >(argp2);
  {
    try {
      result = (Procedural::Triangulator *) &(arg1)->setMultiShapeToTriangulate(arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Procedural__Triangulator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Triangulator_triangulate(int argc, VALUE *argv, VALUE self) {
  Procedural::Triangulator *arg1 = (Procedural::Triangulator *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ;
  Procedural::PointList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Triangulator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Triangulator const *","triangulate", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Triangulator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< int,std::allocator< int > > &","triangulate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< int,std::allocator< int > > &","triangulate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_std__vectorT_Ogre__Vector2_std__allocatorT_Ogre__Vector2_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Procedural::PointList &","triangulate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::PointList &","triangulate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Procedural::PointList * >(argp3);
  {
    try {
      ((Procedural::Triangulator const *)arg1)->triangulate(*arg2,*arg3);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Triangulator_add_to_triangle_buffer(int argc, VALUE *argv, VALUE self) {
  Procedural::Triangulator *arg1 = (Procedural::Triangulator *) 0 ;
  Procedural::TriangleBuffer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Procedural__Triangulator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Procedural::Triangulator const *","addToTriangleBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Procedural::Triangulator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Procedural__TriangleBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Procedural::TriangleBuffer &","addToTriangleBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Procedural::TriangleBuffer * >(argp2);
  {
    try {
      ((Procedural::Triangulator const *)arg1)->addToTriangleBuffer(*arg2);
    } catch(Ogre::Exception& e) {
      static VALUE cpperror = rb_define_class("CPPError", rb_eStandardError);
      rb_raise(cpperror, "%s", e.getFullDescription().c_str());
    }
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Procedural_Triangulator(Procedural::Triangulator *arg1) {
    delete arg1;
}


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_Procedural__BoxGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Procedural::MeshGenerator< Procedural::BoxGenerator > *)  ((Procedural::BoxGenerator *) x));
}
static void *_p_Procedural__TorusKnotGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *)  ((Procedural::TorusKnotGenerator *) x));
}
static void *_p_Procedural__TorusGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Procedural::MeshGenerator< Procedural::TorusGenerator > *)  ((Procedural::TorusGenerator *) x));
}
static void *_p_Procedural__PlaneGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Procedural::MeshGenerator< Procedural::PlaneGenerator > *)  ((Procedural::PlaneGenerator *) x));
}
static void *_p_Procedural__CapsuleGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Procedural::MeshGenerator< Procedural::CapsuleGenerator > *)  ((Procedural::CapsuleGenerator *) x));
}
static void *_p_Ogre__MovablePlaneTo_p_Ogre__Plane(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Plane *)  ((Ogre::MovablePlane *) x));
}
static void *_p_Procedural__PlaneTo_p_Ogre__Plane(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Plane *)  ((Procedural::Plane *) x));
}
static void *_p_Procedural__TubeGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Procedural::MeshGenerator< Procedural::TubeGenerator > *)  ((Procedural::TubeGenerator *) x));
}
static void *_p_Procedural__ConeGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Procedural::MeshGenerator< Procedural::ConeGenerator > *)  ((Procedural::ConeGenerator *) x));
}
static void *_p_Procedural__RoundedBoxGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *)  ((Procedural::RoundedBoxGenerator *) x));
}
static void *_p_IntpTo_p_int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int *)  ((Intp *) x));
}
static void *_p_Procedural__IcoSphereGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *)  ((Procedural::IcoSphereGenerator *) x));
}
static void *_p_Procedural__CylinderGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Procedural::MeshGenerator< Procedural::CylinderGenerator > *)  ((Procedural::CylinderGenerator *) x));
}
static void *_p_Procedural__SphereGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Procedural::MeshGenerator< Procedural::SphereGenerator > *)  ((Procedural::SphereGenerator *) x));
}
static swig_type_info _swigt__p_AliasTextureIterator = {"_p_AliasTextureIterator", "AliasTextureIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AnimationIterator = {"_p_AnimationIterator", "AnimationIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ArchiveMapIterator = {"_p_ArchiveMapIterator", "ArchiveMapIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AutoConstantIterator = {"_p_AutoConstantIterator", "AutoConstantIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_AutoConstantList = {"_p_AutoConstantList", "AutoConstantList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BatchInstanceIterator = {"_p_BatchInstanceIterator", "BatchInstanceIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BatchInstanceMap = {"_p_BatchInstanceMap", "BatchInstanceMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BindingIndexMap = {"_p_BindingIndexMap", "BindingIndexMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BoneAssignmentIterator = {"_p_BoneAssignmentIterator", "BoneAssignmentIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BoneBlendMask = {"_p_BoneBlendMask", "BoneBlendMask *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BoneHandleMap = {"_p_BoneHandleMap", "BoneHandleMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BoneIterator = {"_p_BoneIterator", "BoneIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BoneList = {"_p_BoneList", "BoneList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_BoundSufaceList = {"_p_BoundSufaceList", "BoundSufaceList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Box = {"_p_Box", "Box *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraIterator = {"_p_CameraIterator", "CameraIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CameraList = {"_p_CameraList", "CameraList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ChildContainerIterator = {"_p_ChildContainerIterator", "ChildContainerIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ChildContainerMap = {"_p_ChildContainerMap", "ChildContainerMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ChildIterator = {"_p_ChildIterator", "ChildIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ChildMap = {"_p_ChildMap", "ChildMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ChildNodeIterator = {"_p_ChildNodeIterator", "ChildNodeIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ChildNodeMap = {"_p_ChildNodeMap", "ChildNodeMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ChildObjectList = {"_p_ChildObjectList", "ChildObjectList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ChildObjectListIterator = {"_p_ChildObjectListIterator", "ChildObjectListIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CodePoint = {"_p_CodePoint", "CodePoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CodePointRange = {"_p_CodePointRange", "CodePointRange *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CodePointRangeList = {"_p_CodePointRangeList", "CodePointRangeList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CodecDataPtr = {"_p_CodecDataPtr", "CodecDataPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CodecIterator = {"_p_CodecIterator", "CodecIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CompiledState = {"_p_CompiledState", "CompiledState *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstChildNodeIterator = {"_p_ConstChildNodeIterator", "ConstChildNodeIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstNormalsIterator = {"_p_ConstNormalsIterator", "ConstNormalsIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstObjectIterator = {"_p_ConstObjectIterator", "ConstObjectIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstPoseIterator = {"_p_ConstPoseIterator", "ConstPoseIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstPoseRefIterator = {"_p_ConstPoseRefIterator", "ConstPoseRefIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstPriorityMapIterator = {"_p_ConstPriorityMapIterator", "ConstPriorityMapIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstQueueGroupIterator = {"_p_ConstQueueGroupIterator", "ConstQueueGroupIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstTerrainIterator = {"_p_ConstTerrainIterator", "ConstTerrainIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstTextureUnitStateIterator = {"_p_ConstTextureUnitStateIterator", "ConstTextureUnitStateIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstVertexOffsetIterator = {"_p_ConstVertexOffsetIterator", "ConstVertexOffsetIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ContentCollectionFactoryMap = {"_p_ContentCollectionFactoryMap", "ContentCollectionFactoryMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ContentCollectionList = {"_p_ContentCollectionList", "ContentCollectionList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ContentFactoryMap = {"_p_ContentFactoryMap", "ContentFactoryMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ContentList = {"_p_ContentList", "ContentList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_CornerEnum = {"_p_CornerEnum", "CornerEnum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DecodeResult = {"_p_DecodeResult", "DecodeResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Edge = {"_p_Edge", "Edge *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EdgeGroupList = {"_p_EdgeGroupList", "EdgeGroupList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EdgeList = {"_p_EdgeList", "EdgeList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EdgeMap = {"_p_EdgeMap", "EdgeMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EffectMap = {"_p_EffectMap", "EffectMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ElementList = {"_p_ElementList", "ElementList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ElementMap = {"_p_ElementMap", "ElementMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_EntitySet = {"_p_EntitySet", "EntitySet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ErrorList = {"_p_ErrorList", "ErrorList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ErrorPtr = {"_p_ErrorPtr", "ErrorPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FactoryMap = {"_p_FactoryMap", "FactoryMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GPUDeviceNameRuleIterator = {"_p_GPUDeviceNameRuleIterator", "GPUDeviceNameRuleIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GPUDeviceNameRuleList = {"_p_GPUDeviceNameRuleList", "GPUDeviceNameRuleList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GPUVendorRuleIterator = {"_p_GPUVendorRuleIterator", "GPUVendorRuleIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GPUVendorRuleList = {"_p_GPUVendorRuleList", "GPUVendorRuleList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_GpuSharedParamUsageList = {"_p_GpuSharedParamUsageList", "GpuSharedParamUsageList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_HardwareAnimationDataList = {"_p_HardwareAnimationDataList", "HardwareAnimationDataList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IdMap = {"_p_IdMap", "IdMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IlluminationPassIterator = {"_p_IlluminationPassIterator", "IlluminationPassIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IndexMap = {"_p_IndexMap", "IndexMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IndexRemapList = {"_p_IndexRemapList", "IndexRemapList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InstanceBatchIterator = {"_p_InstanceBatchIterator", "InstanceBatchIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InstanceBatchMapIterator = {"_p_InstanceBatchMapIterator", "InstanceBatchMapIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InstanceIterator = {"_p_InstanceIterator", "InstanceIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_InstancedEntityVec = {"_p_InstancedEntityVec", "InstancedEntityVec *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Instances = {"_p_Instances", "Instances *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LODFaceList = {"_p_LODFaceList", "LODFaceList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LayerInstanceList = {"_p_LayerInstanceList", "LayerInstanceList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LinkedSkeletonAnimSourceIterator = {"_p_LinkedSkeletonAnimSourceIterator", "LinkedSkeletonAnimSourceIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LinkedSkeletonAnimSourceList = {"_p_LinkedSkeletonAnimSourceList", "LinkedSkeletonAnimSourceList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LocationList = {"_p_LocationList", "LocationList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LodLevelList = {"_p_LodLevelList", "LodLevelList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LodValueIterator = {"_p_LodValueIterator", "LodValueIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LodValueList = {"_p_LodValueList", "LodValueList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MeshLodUsageList = {"_p_MeshLodUsageList", "MeshLodUsageList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MetaDataIterator = {"_p_MetaDataIterator", "MetaDataIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MetaDataList = {"_p_MetaDataList", "MetaDataList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Microcode = {"_p_Microcode", "Microcode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MicrocodeMap = {"_p_MicrocodeMap", "MicrocodeMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MovableObjectFactoryIterator = {"_p_MovableObjectFactoryIterator", "MovableObjectFactoryIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_MovableObjectIterator = {"_p_MovableObjectIterator", "MovableObjectIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NodeIterator = {"_p_NodeIterator", "NodeIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NodeList = {"_p_NodeList", "NodeList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NodeTrackIterator = {"_p_NodeTrackIterator", "NodeTrackIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NodeTrackList = {"_p_NodeTrackList", "NodeTrackList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NormalsIterator = {"_p_NormalsIterator", "NormalsIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NormalsMap = {"_p_NormalsMap", "NormalsMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NumericTrackIterator = {"_p_NumericTrackIterator", "NumericTrackIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_NumericTrackList = {"_p_NumericTrackList", "NumericTrackList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ObjectIterator = {"_p_ObjectIterator", "ObjectIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ObjectMap = {"_p_ObjectMap", "ObjectMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_ANIMATION_t_t = {"_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_ANIMATION_t_t", "Ogre::AnimationAllocatedObject *|Ogre::AllocatedObject< Ogre::CategorisedAllocPolicy< Ogre::MEMCATEGORY_ANIMATION > > *|Ogre::AnimationAlloc *|Ogre::AnimableAlloc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GENERAL_t_t = {"_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GENERAL_t_t", "Ogre::AllocatedObject< Ogre::CategorisedAllocPolicy< Ogre::MEMCATEGORY_GENERAL > > *|Ogre::GeneralAllocatedObject *|Ogre::ControllerAlloc *|Ogre::ProfilerAlloc *|Ogre::SerializerAlloc *|Ogre::ConfigAlloc *|Ogre::LogAlloc *|Ogre::UtilityAlloc *|Ogre::FactoryAlloc *|Ogre::TerrainAlloc *|Ogre::PluginAlloc *|Ogre::PageAlloc *|Ogre::ImageAlloc *|Ogre::StreamAlloc *|Ogre::TimerAlloc *|Ogre::DynLibAlloc *|Ogre::CodecAlloc *|Ogre::RootAlloc *|Ogre::ArchiveAlloc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_t_t = {"_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_t_t", "Ogre::GeometryAllocatedObject *|Ogre::AllocatedObject< Ogre::CategorisedAllocPolicy< Ogre::MEMCATEGORY_GEOMETRY > > *|Ogre::BatchedGeometryAlloc *|Ogre::PatchAlloc *|Ogre::ProgMeshAlloc *|Ogre::EdgeDataAlloc *|Ogre::IndexDataAlloc *|Ogre::VertexDataAlloc *|Ogre::DebugGeomAlloc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RENDERSYS_t_t = {"_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RENDERSYS_t_t", "Ogre::RenderSysAllocatedObject *|Ogre::AllocatedObject< Ogre::CategorisedAllocPolicy< Ogre::MEMCATEGORY_RENDERSYS > > *|Ogre::BufferAlloc *|Ogre::GpuParamsAlloc *|Ogre::RenderSysAlloc *|Ogre::ViewportAlloc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RESOURCE_t_t = {"_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RESOURCE_t_t", "Ogre::ResourceAllocatedObject *|Ogre::AllocatedObject< Ogre::CategorisedAllocPolicy< Ogre::MEMCATEGORY_RESOURCE > > *|Ogre::SubMeshAlloc *|Ogre::PassAlloc *|Ogre::ResourceAlloc *|Ogre::TechniqueAlloc *|Ogre::TextureUnitStateAlloc *|Ogre::CompositorInstAlloc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_CONTROL_t_t = {"_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_CONTROL_t_t", "Ogre::SceneCtlAllocatedObject *|Ogre::AllocatedObject< Ogre::CategorisedAllocPolicy< Ogre::MEMCATEGORY_SCENE_CONTROL > > *|Ogre::LodAlloc *|Ogre::RenderQueueAlloc *|Ogre::ShadowDataAlloc *|Ogre::NodeAlloc *|Ogre::SceneMgtAlloc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_OBJECTS_t_t = {"_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_OBJECTS_t_t", "Ogre::SceneObjAllocatedObject *|Ogre::AllocatedObject< Ogre::CategorisedAllocPolicy< Ogre::MEMCATEGORY_SCENE_OBJECTS > > *|Ogre::OverlayAlloc *|Ogre::SubEntityAlloc *|Ogre::MovableAlloc *|Ogre::FXAlloc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCRIPTING_t_t = {"_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCRIPTING_t_t", "Ogre::ScriptingAllocatedObject *|Ogre::AllocatedObject< Ogre::CategorisedAllocPolicy< Ogre::MEMCATEGORY_SCRIPTING > > *|Ogre::ScriptCompilerAlloc *|Ogre::ScriptTranslatorAlloc *|Ogre::AbstractNodeAlloc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AnimationStateIterator = {"_p_Ogre__AnimationStateIterator", "Ogre::AnimationStateIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AxisAlignedBox = {"_p_Ogre__AxisAlignedBox", "Ogre::AxisAlignedBox *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_ANIMATION_t = {"_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_ANIMATION_t", "Ogre::CategorisedAllocPolicy< Ogre::MEMCATEGORY_ANIMATION > *|Ogre::AnimationAllocPolicy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GENERAL_t = {"_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GENERAL_t", "Ogre::GeneralAllocPolicy *|Ogre::CategorisedAllocPolicy< Ogre::MEMCATEGORY_GENERAL > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_t = {"_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_t", "Ogre::GeometryAllocPolicy *|Ogre::CategorisedAllocPolicy< Ogre::MEMCATEGORY_GEOMETRY > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RENDERSYS_t = {"_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RENDERSYS_t", "Ogre::RenderSysAllocPolicy *|Ogre::CategorisedAllocPolicy< Ogre::MEMCATEGORY_RENDERSYS > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RESOURCE_t = {"_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RESOURCE_t", "Ogre::ResourceAllocPolicy *|Ogre::CategorisedAllocPolicy< Ogre::MEMCATEGORY_RESOURCE > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_CONTROL_t = {"_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_CONTROL_t", "Ogre::CategorisedAllocPolicy< Ogre::MEMCATEGORY_SCENE_CONTROL > *|Ogre::SceneCtlAllocPolicy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_OBJECTS_t = {"_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_OBJECTS_t", "Ogre::CategorisedAllocPolicy< Ogre::MEMCATEGORY_SCENE_OBJECTS > *|Ogre::SceneObjAllocPolicy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCRIPTING_t = {"_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCRIPTING_t", "Ogre::CategorisedAllocPolicy< Ogre::MEMCATEGORY_SCRIPTING > *|Ogre::ScriptingAllocPolicy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConstAnimationStateIterator = {"_p_Ogre__ConstAnimationStateIterator", "Ogre::ConstAnimationStateIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConstEnabledAnimationStateIterator = {"_p_Ogre__ConstEnabledAnimationStateIterator", "Ogre::ConstEnabledAnimationStateIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__GpuConstantDefinition_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuConstantDefinition_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__GpuConstantDefinition_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuConstantDefinition_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::GpuConstantDefinitionIterator *|Ogre::ConstMapIterator< Ogre::map< Ogre::String,Ogre::GpuConstantDefinition,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::GpuConstantDefinition >,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConstShadowTextureConfigIterator = {"_p_Ogre__ConstShadowTextureConfigIterator", "Ogre::ConstShadowTextureConfigIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__HashedVectorT_Ogre__Light_p_t = {"_p_Ogre__HashedVectorT_Ogre__Light_p_t", "Ogre::LightList *|Ogre::HashedVector< Ogre::Light * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ManualObject = {"_p_Ogre__ManualObject", "Ogre::ManualObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Matrix4 = {"_p_Ogre__Matrix4", "Ogre::Matrix4 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MeshPtr = {"_p_Ogre__MeshPtr", "Ogre::MeshPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Plane = {"_p_Ogre__Plane", "Ogre::Plane *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MovablePlane = {"_p_Ogre__MovablePlane", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_Ogre__Quaternion = {"_p_Ogre__Quaternion", "Ogre::Quaternion *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Radian = {"_p_Ogre__Radian", "Ogre::Radian *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Rectangle = {"_p_Ogre__Rectangle", "Ogre::Rectangle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__AbstractNode_t = {"_p_Ogre__SharedPtrT_Ogre__AbstractNode_t", "Ogre::SharedPtr< Ogre::AbstractNode > *|Ogre::AbstractNodePtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__AnimableValue_t = {"_p_Ogre__SharedPtrT_Ogre__AnimableValue_t", "Ogre::SharedPtr< Ogre::AnimableValue > *|Ogre::AnimableValuePtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__ConcreteNode_t = {"_p_Ogre__SharedPtrT_Ogre__ConcreteNode_t", "Ogre::SharedPtr< Ogre::ConcreteNode > *|Ogre::ConcreteNodePtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__ControllerFunctionT_float_t_t = {"_p_Ogre__SharedPtrT_Ogre__ControllerFunctionT_float_t_t", "Ogre::SharedPtr< Ogre::ControllerFunction< float > > *|Ogre::ControllerFunctionRealPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__ControllerValueT_float_t_t = {"_p_Ogre__SharedPtrT_Ogre__ControllerValueT_float_t_t", "Ogre::SharedPtr< Ogre::ControllerValue< float > > *|Ogre::ControllerValueRealPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__DataStream_t = {"_p_Ogre__SharedPtrT_Ogre__DataStream_t", "Ogre::SharedPtr< Ogre::DataStream > *|Ogre::DataStreamPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__GpuLogicalBufferStruct_t = {"_p_Ogre__SharedPtrT_Ogre__GpuLogicalBufferStruct_t", "Ogre::SharedPtr< Ogre::GpuLogicalBufferStruct > *|Ogre::GpuLogicalBufferStructPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__GpuNamedConstants_t = {"_p_Ogre__SharedPtrT_Ogre__GpuNamedConstants_t", "Ogre::SharedPtr< Ogre::GpuNamedConstants > *|Ogre::GpuNamedConstantsPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t = {"_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t", "Ogre::GpuProgramParametersSharedPtr *|Ogre::SharedPtr< Ogre::GpuProgramParameters > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__GpuSharedParameters_t = {"_p_Ogre__SharedPtrT_Ogre__GpuSharedParameters_t", "Ogre::SharedPtr< Ogre::GpuSharedParameters > *|Ogre::GpuSharedParametersPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__MemoryDataStream_t = {"_p_Ogre__SharedPtrT_Ogre__MemoryDataStream_t", "Ogre::SharedPtr< Ogre::MemoryDataStream > *|Ogre::MemoryDataStreamPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__RenderToVertexBuffer_t = {"_p_Ogre__SharedPtrT_Ogre__RenderToVertexBuffer_t", "Ogre::SharedPtr< Ogre::RenderToVertexBuffer > *|Ogre::RenderToVertexBufferSharedPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__Resource_t = {"_p_Ogre__SharedPtrT_Ogre__Resource_t", "Ogre::SharedPtr< Ogre::Resource > *|Ogre::ResourcePtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__ScriptToken_t = {"_p_Ogre__SharedPtrT_Ogre__ScriptToken_t", "Ogre::ScriptTokenPtr *|Ogre::SharedPtr< Ogre::ScriptToken > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__ShadowCameraSetup_t = {"_p_Ogre__SharedPtrT_Ogre__ShadowCameraSetup_t", "Ogre::SharedPtr< Ogre::ShadowCameraSetup > *|Ogre::ShadowCameraSetupPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__TerrainMaterialGenerator_t = {"_p_Ogre__SharedPtrT_Ogre__TerrainMaterialGenerator_t", "Ogre::TerrainMaterialGeneratorPtr *|Ogre::SharedPtr< Ogre::TerrainMaterialGenerator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::SharedPtr< Ogre::list< Ogre::AbstractNodePtr,Ogre::STLAllocator< Ogre::AbstractNodePtr,Ogre::GeneralAllocPolicy > >::type > *|Ogre::AbstractNodeListPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__SharedPtrT_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::SharedPtr< Ogre::list< Ogre::ConcreteNodePtr,Ogre::STLAllocator< Ogre::ConcreteNodePtr,Ogre::GeneralAllocPolicy > >::type > *|Ogre::ConcreteNodeListPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__listT_Ogre__DataStreamPtr_Ogre__STLAllocatorT_Ogre__DataStreamPtr_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__SharedPtrT_Ogre__listT_Ogre__DataStreamPtr_Ogre__STLAllocatorT_Ogre__DataStreamPtr_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::SharedPtr< Ogre::list< Ogre::DataStreamPtr,Ogre::STLAllocator< Ogre::DataStreamPtr,Ogre::GeneralAllocPolicy > >::type > *|Ogre::DataStreamListPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > *|Ogre::FileInfoListPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__ScriptTokenPtr_Ogre__STLAllocatorT_Ogre__ScriptTokenPtr_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__ScriptTokenPtr_Ogre__STLAllocatorT_Ogre__ScriptTokenPtr_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::SharedPtr< Ogre::vector< Ogre::ScriptTokenPtr,Ogre::STLAllocator< Ogre::ScriptTokenPtr,Ogre::GeneralAllocPolicy > >::type > *|Ogre::ScriptTokenListPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::StringVectorPtr *|Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SimpleSpline = {"_p_Ogre__SimpleSpline", "Ogre::SimpleSpline *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TRectT_float_t = {"_p_Ogre__TRectT_float_t", "Ogre::TRect< float > *|Ogre::FloatRect *|Ogre::RealRect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TRectT_long_t = {"_p_Ogre__TRectT_long_t", "Ogre::TRect< long > *|Ogre::Rect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__UTFString = {"_p_Ogre__UTFString", "Ogre::UTFString *|Ogre::DisplayString *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Vector2 = {"_p_Ogre__Vector2", "Ogre::Vector2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Vector3 = {"_p_Ogre__Vector3", "Ogre::Vector3 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__RenderQueueInvocation_p_Ogre__STLAllocatorT_Ogre__RenderQueueInvocation_p_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__RenderQueueInvocation_p_Ogre__STLAllocatorT_Ogre__RenderQueueInvocation_p_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::VectorIterator< Ogre::vector< Ogre::RenderQueueInvocation *,Ogre::STLAllocator< Ogre::RenderQueueInvocation *,Ogre::GeneralAllocPolicy > >::type > *|Ogre::RenderQueueInvocationIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VertexBoneAssignment_s = {"_p_Ogre__VertexBoneAssignment_s", "Ogre::VertexBoneAssignment_s *|Ogre::VertexBoneAssignment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre___ConfigOption = {"_p_Ogre___ConfigOption", "Ogre::_ConfigOption *|Ogre::ConfigOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::list< Ogre::AbstractNodePtr,Ogre::STLAllocator< Ogre::AbstractNodePtr,Ogre::GeneralAllocPolicy > >::type *|Ogre::AbstractNodeList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__listT_Ogre__AnimationState_p_Ogre__STLAllocatorT_Ogre__AnimationState_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__listT_Ogre__AnimationState_p_Ogre__STLAllocatorT_Ogre__AnimationState_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::EnabledAnimationStateList *|Ogre::list< Ogre::AnimationState *,Ogre::STLAllocator< Ogre::AnimationState *,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::list< Ogre::ConcreteNodePtr,Ogre::STLAllocator< Ogre::ConcreteNodePtr,Ogre::GeneralAllocPolicy > >::type *|Ogre::ConcreteNodeList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__listT_Ogre__DataStreamPtr_Ogre__STLAllocatorT_Ogre__DataStreamPtr_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__listT_Ogre__DataStreamPtr_Ogre__STLAllocatorT_Ogre__DataStreamPtr_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::DataStreamList *|Ogre::list< Ogre::DataStreamPtr,Ogre::STLAllocator< Ogre::DataStreamPtr,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__listT_Ogre__MovableObject_p_Ogre__STLAllocatorT_Ogre__MovableObject_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__listT_Ogre__MovableObject_p_Ogre__STLAllocatorT_Ogre__MovableObject_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::list< Ogre::MovableObject *,Ogre::STLAllocator< Ogre::MovableObject *,Ogre::GeneralAllocPolicy > >::type *|Ogre::SceneQueryResultMovableList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__listT_Ogre__SceneQueryMovableObjectPair_Ogre__STLAllocatorT_Ogre__SceneQueryMovableObjectPair_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__listT_Ogre__SceneQueryMovableObjectPair_Ogre__STLAllocatorT_Ogre__SceneQueryMovableObjectPair_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::SceneQueryMovableIntersectionList *|Ogre::list< Ogre::SceneQueryMovableObjectPair,Ogre::STLAllocator< Ogre::SceneQueryMovableObjectPair,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__listT_Ogre__SceneQueryMovableObjectWorldFragmentPair_Ogre__STLAllocatorT_Ogre__SceneQueryMovableObjectWorldFragmentPair_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__listT_Ogre__SceneQueryMovableObjectWorldFragmentPair_Ogre__STLAllocatorT_Ogre__SceneQueryMovableObjectWorldFragmentPair_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::list< Ogre::SceneQueryMovableObjectWorldFragmentPair,Ogre::STLAllocator< Ogre::SceneQueryMovableObjectWorldFragmentPair,Ogre::GeneralAllocPolicy > >::type *|Ogre::SceneQueryMovableWorldFragmentIntersectionList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__listT_Ogre__WorldFragment_p_Ogre__STLAllocatorT_Ogre__WorldFragment_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__listT_Ogre__WorldFragment_p_Ogre__STLAllocatorT_Ogre__WorldFragment_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::list< Ogre::WorldFragment *,Ogre::STLAllocator< Ogre::WorldFragment *,Ogre::GeneralAllocPolicy > >::type *|Ogre::SceneQueryResultWorldFragmentList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_Ogre__String_Ogre__AnimationState_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__AnimationState_p_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_Ogre__String_Ogre__AnimationState_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__AnimationState_p_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::map< Ogre::String,Ogre::AnimationState *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::AnimationState * >,Ogre::GeneralAllocPolicy > >::type *|Ogre::AnimationStateMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_Ogre__String_Ogre__ConfigOption_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ConfigOption_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_Ogre__String_Ogre__ConfigOption_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ConfigOption_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::ConfigOptionMap *|Ogre::map< Ogre::String,Ogre::ConfigOption,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::ConfigOption >,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_Ogre__String_Ogre__GpuConstantDefinition_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuConstantDefinition_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_Ogre__String_Ogre__GpuConstantDefinition_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuConstantDefinition_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::GpuConstantDefinitionMap *|Ogre::map< Ogre::String,Ogre::GpuConstantDefinition,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::GpuConstantDefinition >,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_Ogre__String_Ogre__ParamCommand_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParamCommand_p_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_Ogre__String_Ogre__ParamCommand_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParamCommand_p_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::ParamCommandMap *|Ogre::map< Ogre::String,Ogre::ParamCommand *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::ParamCommand * >,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_Ogre__String_Ogre__ParamDictionary_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParamDictionary_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_Ogre__String_Ogre__ParamDictionary_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParamDictionary_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::map< Ogre::String,Ogre::ParamDictionary,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::ParamDictionary >,Ogre::GeneralAllocPolicy > >::type *|Ogre::ParamDictionaryMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_Ogre__String_Ogre__RenderTarget_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__RenderTarget_p_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_Ogre__String_Ogre__RenderTarget_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__RenderTarget_p_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::map< Ogre::String,Ogre::RenderTarget *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::RenderTarget * >,Ogre::GeneralAllocPolicy > >::type *|Ogre::RenderTargetMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_Ogre__String_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_Ogre__String_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::BinaryOptionList *|Ogre::NameValuePairList *|Ogre::AliasTextureNamePairList *|Ogre::map< Ogre::String,Ogre::String,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::String >,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_Ogre__String_bool_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_bool_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_Ogre__String_bool_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_bool_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::UnaryOptionList *|Ogre::map< Ogre::String,bool,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,bool >,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_Ogre__uint16_Ogre__DepthBufferVec_std__lessT_Ogre__uint16_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint16_const_Ogre__DepthBufferVec_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_Ogre__uint16_Ogre__DepthBufferVec_std__lessT_Ogre__uint16_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint16_const_Ogre__DepthBufferVec_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::DepthBufferMap *|Ogre::map< Ogre::uint16,Ogre::DepthBufferVec,std::less< Ogre::uint16 >,Ogre::STLAllocator< std::pair< Ogre::uint16 const,Ogre::DepthBufferVec >,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_size_t_Ogre__GpuLogicalIndexUse_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__GpuLogicalIndexUse_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_size_t_Ogre__GpuLogicalIndexUse_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__GpuLogicalIndexUse_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::GpuLogicalIndexUseMap *|Ogre::map< size_t,Ogre::GpuLogicalIndexUse,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::GpuLogicalIndexUse >,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__multimapT_Ogre__uchar_Ogre__RenderTarget_p_std__lessT_Ogre__uchar_t_Ogre__STLAllocatorT_std__pairT_Ogre__uchar_const_Ogre__RenderTarget_p_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__multimapT_Ogre__uchar_Ogre__RenderTarget_p_std__lessT_Ogre__uchar_t_Ogre__STLAllocatorT_std__pairT_Ogre__uchar_const_Ogre__RenderTarget_p_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::RenderTargetPriorityMap *|Ogre::multimap< Ogre::uchar,Ogre::RenderTarget *,std::less< Ogre::uchar >,Ogre::STLAllocator< std::pair< Ogre::uchar const,Ogre::RenderTarget * >,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__DepthBuffer_p_Ogre__STLAllocatorT_Ogre__DepthBuffer_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__DepthBuffer_p_Ogre__STLAllocatorT_Ogre__DepthBuffer_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::DepthBuffer *,Ogre::STLAllocator< Ogre::DepthBuffer *,Ogre::GeneralAllocPolicy > >::type *|Ogre::DepthBufferVec *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type *|Ogre::FileInfoList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__HardwareBuffer__Usage_Ogre__STLAllocatorT_Ogre__HardwareBuffer__Usage_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__HardwareBuffer__Usage_Ogre__STLAllocatorT_Ogre__HardwareBuffer__Usage_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::HardwareBuffer::Usage,Ogre::STLAllocator< Ogre::HardwareBuffer::Usage,Ogre::GeneralAllocPolicy > >::type *|Ogre::BufferUsageList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__IlluminationPass_p_Ogre__STLAllocatorT_Ogre__IlluminationPass_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__IlluminationPass_p_Ogre__STLAllocatorT_Ogre__IlluminationPass_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::IlluminationPass *,Ogre::STLAllocator< Ogre::IlluminationPass *,Ogre::GeneralAllocPolicy > >::type *|Ogre::IlluminationPassList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__Image_const_p_Ogre__STLAllocatorT_Ogre__Image_const_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__Image_const_p_Ogre__STLAllocatorT_Ogre__Image_const_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::Image const *,Ogre::STLAllocator< Ogre::Image const *,Ogre::GeneralAllocPolicy > >::type *|Ogre::ConstImagePtrList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__Image_p_Ogre__STLAllocatorT_Ogre__Image_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__Image_p_Ogre__STLAllocatorT_Ogre__Image_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::Image *,Ogre::STLAllocator< Ogre::Image *,Ogre::GeneralAllocPolicy > >::type *|Ogre::ImagePtrList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__ParameterDef_Ogre__STLAllocatorT_Ogre__ParameterDef_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__ParameterDef_Ogre__STLAllocatorT_Ogre__ParameterDef_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::ParameterDef,Ogre::STLAllocator< Ogre::ParameterDef,Ogre::GeneralAllocPolicy > >::type *|Ogre::ParameterList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__PixelFormat_Ogre__STLAllocatorT_Ogre__PixelFormat_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__PixelFormat_Ogre__STLAllocatorT_Ogre__PixelFormat_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::PixelFormatList *|Ogre::vector< Ogre::PixelFormat,Ogre::STLAllocator< Ogre::PixelFormat,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__PlaneBoundedVolume_Ogre__STLAllocatorT_Ogre__PlaneBoundedVolume_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__PlaneBoundedVolume_Ogre__STLAllocatorT_Ogre__PlaneBoundedVolume_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::PlaneBoundedVolume,Ogre::STLAllocator< Ogre::PlaneBoundedVolume,Ogre::GeneralAllocPolicy > >::type *|Ogre::PlaneBoundedVolumeList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::PlaneList *|Ogre::vector< Ogre::Plane,Ogre::STLAllocator< Ogre::Plane,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__Pose_p_Ogre__STLAllocatorT_Ogre__Pose_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__Pose_p_Ogre__STLAllocatorT_Ogre__Pose_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::PoseList *|Ogre::vector< Ogre::Pose *,Ogre::STLAllocator< Ogre::Pose *,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__RaySceneQueryResultEntry_Ogre__STLAllocatorT_Ogre__RaySceneQueryResultEntry_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__RaySceneQueryResultEntry_Ogre__STLAllocatorT_Ogre__RaySceneQueryResultEntry_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::RaySceneQueryResult *|Ogre::vector< Ogre::RaySceneQueryResultEntry,Ogre::STLAllocator< Ogre::RaySceneQueryResultEntry,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__RenderQueueInvocation_p_Ogre__STLAllocatorT_Ogre__RenderQueueInvocation_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__RenderQueueInvocation_p_Ogre__STLAllocatorT_Ogre__RenderQueueInvocation_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::RenderQueueInvocationList *|Ogre::vector< Ogre::RenderQueueInvocation *,Ogre::STLAllocator< Ogre::RenderQueueInvocation *,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__RenderSystem_p_Ogre__STLAllocatorT_Ogre__RenderSystem_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__RenderSystem_p_Ogre__STLAllocatorT_Ogre__RenderSystem_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::RenderSystemList *|Ogre::vector< Ogre::RenderSystem *,Ogre::STLAllocator< Ogre::RenderSystem *,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__RenderWindowDescription_Ogre__STLAllocatorT_Ogre__RenderWindowDescription_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__RenderWindowDescription_Ogre__STLAllocatorT_Ogre__RenderWindowDescription_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::RenderWindowDescriptionList *|Ogre::vector< Ogre::RenderWindowDescription,Ogre::STLAllocator< Ogre::RenderWindowDescription,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__RenderWindow_p_Ogre__STLAllocatorT_Ogre__RenderWindow_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__RenderWindow_p_Ogre__STLAllocatorT_Ogre__RenderWindow_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::RenderWindowList *|Ogre::vector< Ogre::RenderWindow *,Ogre::STLAllocator< Ogre::RenderWindow *,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__ScriptTokenPtr_Ogre__STLAllocatorT_Ogre__ScriptTokenPtr_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__ScriptTokenPtr_Ogre__STLAllocatorT_Ogre__ScriptTokenPtr_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::ScriptTokenList *|Ogre::vector< Ogre::ScriptTokenPtr,Ogre::STLAllocator< Ogre::ScriptTokenPtr,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__ShadowTextureConfig_Ogre__STLAllocatorT_Ogre__ShadowTextureConfig_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__ShadowTextureConfig_Ogre__STLAllocatorT_Ogre__ShadowTextureConfig_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::ShadowTextureConfig,Ogre::STLAllocator< Ogre::ShadowTextureConfig,Ogre::GeneralAllocPolicy > >::type *|Ogre::ShadowTextureConfigList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type *|Ogre::StringVector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__TerrainLayerBlendMap_p_Ogre__STLAllocatorT_Ogre__TerrainLayerBlendMap_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__TerrainLayerBlendMap_p_Ogre__STLAllocatorT_Ogre__TerrainLayerBlendMap_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::TerrainLayerBlendMap *,Ogre::STLAllocator< Ogre::TerrainLayerBlendMap *,Ogre::GeneralAllocPolicy > >::type *|Ogre::TerrainLayerBlendMapList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__TerrainLayerSamplerElement_Ogre__STLAllocatorT_Ogre__TerrainLayerSamplerElement_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__TerrainLayerSamplerElement_Ogre__STLAllocatorT_Ogre__TerrainLayerSamplerElement_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::TerrainLayerSamplerElement,Ogre::STLAllocator< Ogre::TerrainLayerSamplerElement,Ogre::GeneralAllocPolicy > >::type *|Ogre::TerrainLayerSamplerElementList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__TerrainLayerSampler_Ogre__STLAllocatorT_Ogre__TerrainLayerSampler_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__TerrainLayerSampler_Ogre__STLAllocatorT_Ogre__TerrainLayerSampler_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::TerrainLayerSampler,Ogre::STLAllocator< Ogre::TerrainLayerSampler,Ogre::GeneralAllocPolicy > >::type *|Ogre::TerrainLayerSamplerList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__TexturePtr_Ogre__STLAllocatorT_Ogre__TexturePtr_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__TexturePtr_Ogre__STLAllocatorT_Ogre__TexturePtr_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::TexturePtr,Ogre::STLAllocator< Ogre::TexturePtr,Ogre::GeneralAllocPolicy > >::type *|Ogre::ShadowTextureList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_float_Ogre__STLAllocatorT_float_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_float_Ogre__STLAllocatorT_float_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< float,Ogre::STLAllocator< float,Ogre::GeneralAllocPolicy > >::type *|Ogre::FloatConstantList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_int_Ogre__STLAllocatorT_int_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_int_Ogre__STLAllocatorT_int_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::IntConstantList *|Ogre::vector< int,Ogre::STLAllocator< int,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OptimalAdjustFactorList = {"_p_OptimalAdjustFactorList", "OptimalAdjustFactorList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OptimisedSubMeshGeometryList = {"_p_OptimisedSubMeshGeometryList", "OptimisedSubMeshGeometryList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Overlay2DElementsIterator = {"_p_Overlay2DElementsIterator", "Overlay2DElementsIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OverlayContainerList = {"_p_OverlayContainerList", "OverlayContainerList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OverlayMap = {"_p_OverlayMap", "OverlayMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_OverlayMapIterator = {"_p_OverlayMapIterator", "OverlayMapIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PageMap = {"_p_PageMap", "PageMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ParticleAffectorFactoryIterator = {"_p_ParticleAffectorFactoryIterator", "ParticleAffectorFactoryIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ParticleAffectorFactoryMap = {"_p_ParticleAffectorFactoryMap", "ParticleAffectorFactoryMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ParticleEmitterFactoryIterator = {"_p_ParticleEmitterFactoryIterator", "ParticleEmitterFactoryIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ParticleEmitterFactoryMap = {"_p_ParticleEmitterFactoryMap", "ParticleEmitterFactoryMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ParticleRendererFactoryIterator = {"_p_ParticleRendererFactoryIterator", "ParticleRendererFactoryIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ParticleSystemRendererFactoryMap = {"_p_ParticleSystemRendererFactoryMap", "ParticleSystemRendererFactoryMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ParticleSystemTemplateIterator = {"_p_ParticleSystemTemplateIterator", "ParticleSystemTemplateIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ParticleTemplateMap = {"_p_ParticleTemplateMap", "ParticleTemplateMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PassIterator = {"_p_PassIterator", "PassIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PassSet = {"_p_PassSet", "PassSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Passes = {"_p_Passes", "Passes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PlaneList = {"_p_PlaneList", "PlaneList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PluginInstanceList = {"_p_PluginInstanceList", "PluginInstanceList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PluginLibList = {"_p_PluginLibList", "PluginLibList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PolygonList = {"_p_PolygonList", "PolygonList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PoseIterator = {"_p_PoseIterator", "PoseIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PoseRefIterator = {"_p_PoseRefIterator", "PoseRefIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PoseRefList = {"_p_PoseRefList", "PoseRefList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PriorityMap = {"_p_PriorityMap", "PriorityMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_PriorityMapIterator = {"_p_PriorityMapIterator", "PriorityMapIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__BoxGenerator = {"_p_Procedural__BoxGenerator", "Procedural::BoxGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__CapsuleGenerator = {"_p_Procedural__CapsuleGenerator", "Procedural::CapsuleGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__CatmullRomSpline2 = {"_p_Procedural__CatmullRomSpline2", "Procedural::CatmullRomSpline2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__CatmullRomSpline3 = {"_p_Procedural__CatmullRomSpline3", "Procedural::CatmullRomSpline3 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__Circle = {"_p_Procedural__Circle", "Procedural::Circle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__CircleShape = {"_p_Procedural__CircleShape", "Procedural::CircleShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__ConeGenerator = {"_p_Procedural__ConeGenerator", "Procedural::ConeGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__CubicHermiteSpline2 = {"_p_Procedural__CubicHermiteSpline2", "Procedural::CubicHermiteSpline2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__CubicHermiteSpline3 = {"_p_Procedural__CubicHermiteSpline3", "Procedural::CubicHermiteSpline3 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__CylinderGenerator = {"_p_Procedural__CylinderGenerator", "Procedural::CylinderGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__Extruder = {"_p_Procedural__Extruder", "Procedural::Extruder *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__IcoSphereGenerator = {"_p_Procedural__IcoSphereGenerator", "Procedural::IcoSphereGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__KochanekBartelsSpline2 = {"_p_Procedural__KochanekBartelsSpline2", "Procedural::KochanekBartelsSpline2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__Lathe = {"_p_Procedural__Lathe", "Procedural::Lathe *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__Line = {"_p_Procedural__Line", "Procedural::Line *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__Line2D = {"_p_Procedural__Line2D", "Procedural::Line2D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__LinePath = {"_p_Procedural__LinePath", "Procedural::LinePath *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t = {"_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t", "Procedural::MeshGenerator< Procedural::BoxGenerator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t = {"_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t", "Procedural::MeshGenerator< Procedural::CapsuleGenerator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t = {"_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t", "Procedural::MeshGenerator< Procedural::ConeGenerator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t = {"_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t", "Procedural::MeshGenerator< Procedural::CylinderGenerator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t = {"_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t", "Procedural::MeshGenerator< Procedural::IcoSphereGenerator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t = {"_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t", "Procedural::MeshGenerator< Procedural::PlaneGenerator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t = {"_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t", "Procedural::MeshGenerator< Procedural::RoundedBoxGenerator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t = {"_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t", "Procedural::MeshGenerator< Procedural::SphereGenerator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t = {"_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t", "Procedural::MeshGenerator< Procedural::TorusGenerator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t = {"_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t", "Procedural::MeshGenerator< Procedural::TorusKnotGenerator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t = {"_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t", "Procedural::MeshGenerator< Procedural::TubeGenerator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__MultiShape = {"_p_Procedural__MultiShape", "Procedural::MultiShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__Path = {"_p_Procedural__Path", "Procedural::Path *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__Plane = {"_p_Procedural__Plane", "Procedural::Plane *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__PlaneGenerator = {"_p_Procedural__PlaneGenerator", "Procedural::PlaneGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__RectangleShape = {"_p_Procedural__RectangleShape", "Procedural::RectangleShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__Root = {"_p_Procedural__Root", "Procedural::Root *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__RoundedBoxGenerator = {"_p_Procedural__RoundedBoxGenerator", "Procedural::RoundedBoxGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__RoundedCornerSpline2 = {"_p_Procedural__RoundedCornerSpline2", "Procedural::RoundedCornerSpline2 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__RoundedCornerSpline3 = {"_p_Procedural__RoundedCornerSpline3", "Procedural::RoundedCornerSpline3 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__Segment2D = {"_p_Procedural__Segment2D", "Procedural::Segment2D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__Shape = {"_p_Procedural__Shape", "Procedural::Shape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__SphereGenerator = {"_p_Procedural__SphereGenerator", "Procedural::SphereGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__TorusGenerator = {"_p_Procedural__TorusGenerator", "Procedural::TorusGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__TorusKnotGenerator = {"_p_Procedural__TorusKnotGenerator", "Procedural::TorusKnotGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__Track = {"_p_Procedural__Track", "Procedural::Track *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__TriangleBuffer = {"_p_Procedural__TriangleBuffer", "Procedural::TriangleBuffer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__Triangulator = {"_p_Procedural__Triangulator", "Procedural::Triangulator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__TubeGenerator = {"_p_Procedural__TubeGenerator", "Procedural::TubeGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Procedural__Utils = {"_p_Procedural__Utils", "Procedural::Utils *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ProfileList = {"_p_ProfileList", "ProfileList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QuadMaterialMap = {"_p_QuadMaterialMap", "QuadMaterialMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QueueGroupIterator = {"_p_QueueGroupIterator", "QueueGroupIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QueuedGeometryList = {"_p_QueuedGeometryList", "QueuedGeometryList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QueuedSubMeshList = {"_p_QueuedSubMeshList", "QueuedSubMeshList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_QueuedSubMeshOriginList = {"_p_QueuedSubMeshOriginList", "QueuedSubMeshOriginList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RealVector = {"_p_RealVector", "RealVector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Rect = {"_p_Rect", "Rect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RegionIterator = {"_p_RegionIterator", "RegionIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RegionMap = {"_p_RegionMap", "RegionMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RenderOperationVector = {"_p_RenderOperationVector", "RenderOperationVector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RenderSystemOpPair = {"_p_RenderSystemOpPair", "RenderSystemOpPair *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RenderSystemOpPairs = {"_p_RenderSystemOpPairs", "RenderSystemOpPairs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RenderTargetIterator = {"_p_RenderTargetIterator", "RenderTargetIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RequestID = {"_p_RequestID", "RequestID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ResourceCreateOrRetrieveResult = {"_p_ResourceCreateOrRetrieveResult", "ResourceCreateOrRetrieveResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ResourceDeclarationList = {"_p_ResourceDeclarationList", "ResourceDeclarationList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ResourceHandleMap = {"_p_ResourceHandleMap", "ResourceHandleMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ResourceManagerIterator = {"_p_ResourceManagerIterator", "ResourceManagerIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ResourceManagerMap = {"_p_ResourceManagerMap", "ResourceManagerMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ResourceMap = {"_p_ResourceMap", "ResourceMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ResourceMapIterator = {"_p_ResourceMapIterator", "ResourceMapIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ResourceWithGroupMap = {"_p_ResourceWithGroupMap", "ResourceWithGroupMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SceneManagerIterator = {"_p_SceneManagerIterator", "SceneManagerIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SchemeHardwareAnimMap = {"_p_SchemeHardwareAnimMap", "SchemeHardwareAnimMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SectionIterator = {"_p_SectionIterator", "SectionIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SectionList = {"_p_SectionList", "SectionList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SectionMap = {"_p_SectionMap", "SectionMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SettingsBySection = {"_p_SettingsBySection", "SettingsBySection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SettingsIterator = {"_p_SettingsIterator", "SettingsIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SettingsMultiMap = {"_p_SettingsMultiMap", "SettingsMultiMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ShaderProfiles = {"_p_ShaderProfiles", "ShaderProfiles *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ShadowRenderableList = {"_p_ShadowRenderableList", "ShadowRenderableList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ShadowRenderableListIterator = {"_p_ShadowRenderableListIterator", "ShadowRenderableListIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SharedParametersMap = {"_p_SharedParametersMap", "SharedParametersMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SplitPointList = {"_p_SplitPointList", "SplitPointList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_StrStreamType = {"_p_StrStreamType", "StrStreamType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_StrategyMap = {"_p_StrategyMap", "StrategyMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SubMeshGeometryLookup = {"_p_SubMeshGeometryLookup", "SubMeshGeometryLookup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SubMeshIterator = {"_p_SubMeshIterator", "SubMeshIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SubMeshList = {"_p_SubMeshList", "SubMeshList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SubMeshLodGeometryLinkList = {"_p_SubMeshLodGeometryLinkList", "SubMeshLodGeometryLinkList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SubMeshNameMap = {"_p_SubMeshNameMap", "SubMeshNameMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SyntaxCodes = {"_p_SyntaxCodes", "SyntaxCodes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TargetPassIterator = {"_p_TargetPassIterator", "TargetPassIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TargetPasses = {"_p_TargetPasses", "TargetPasses *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TechniqueIterator = {"_p_TechniqueIterator", "TechniqueIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Techniques = {"_p_Techniques", "Techniques *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TemplateIterator = {"_p_TemplateIterator", "TemplateIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TerrainIterator = {"_p_TerrainIterator", "TerrainIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TerrainList = {"_p_TerrainList", "TerrainList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TerrainSlotMap = {"_p_TerrainSlotMap", "TerrainSlotMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TextureDefinitionIterator = {"_p_TextureDefinitionIterator", "TextureDefinitionIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TextureDefinitions = {"_p_TextureDefinitions", "TextureDefinitions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TextureUnitStateIterator = {"_p_TextureUnitStateIterator", "TextureUnitStateIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TrackHandleList = {"_p_TrackHandleList", "TrackHandleList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TriangleFaceNormalList = {"_p_TriangleFaceNormalList", "TriangleFaceNormalList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TriangleLightFacingList = {"_p_TriangleLightFacingList", "TriangleLightFacingList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_TriangleList = {"_p_TriangleList", "TriangleList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UVRect = {"_p_UVRect", "UVRect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_UniqueTextureSet = {"_p_UniqueTextureSet", "UniqueTextureSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VertexBoneAssignmentList = {"_p_VertexBoneAssignmentList", "VertexBoneAssignmentList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VertexBufferBindingMap = {"_p_VertexBufferBindingMap", "VertexBufferBindingMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VertexElementList = {"_p_VertexElementList", "VertexElementList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VertexList = {"_p_VertexList", "VertexList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VertexOffsetIterator = {"_p_VertexOffsetIterator", "VertexOffsetIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VertexOffsetMap = {"_p_VertexOffsetMap", "VertexOffsetMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VertexSplit = {"_p_VertexSplit", "VertexSplit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VertexSplits = {"_p_VertexSplits", "VertexSplits *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VertexTrackIterator = {"_p_VertexTrackIterator", "VertexTrackIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_VertexTrackList = {"_p_VertexTrackList", "VertexTrackList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_WindowEventListeners = {"_p_WindowEventListeners", "WindowEventListeners *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Windows = {"_p_Windows", "Windows *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_WorldMap = {"_p_WorldMap", "WorldMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_WorldSectionFactoryMap = {"_p_WorldSectionFactoryMap", "WorldSectionFactoryMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__zzip_plugin_io = {"_p__zzip_plugin_io", "_zzip_plugin_io *|zzip_plugin_io_handlers *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *|Ogre::int8 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_code_point = {"_p_code_point", "code_point *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_const_iterator = {"_p_const_iterator", "const_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_const_reverse_iterator = {"_p_const_reverse_iterator", "const_reverse_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_dstring = {"_p_dstring", "dstring *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_float = {"_p_float", "float *|Ogre::Real *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "Ogre::TrackVertexColourType *|int *|Ogre::int32 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Intp = {"_p_Intp", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_iterator = {"_p_iterator", "iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long_long = {"_p_long_long", "Ogre::int64 *|long long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_reverse_iterator = {"_p_reverse_iterator", "reverse_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_short = {"_p_short", "Ogre::int16 *|short *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", "Ogre::StringStream *|Ogre::stringstream *|std::basic_stringstream< char,std::char_traits< char >,std::allocator< char > > *|Ogre::_StringStreamBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_Ogre__Real_Ogre__Real_std__lessT_Ogre__Real_t_std__allocatorT_std__pairT_Ogre__Real_const_Ogre__Real_t_t_t__const_iterator = {"_p_std__mapT_Ogre__Real_Ogre__Real_std__lessT_Ogre__Real_t_std__allocatorT_std__pairT_Ogre__Real_const_Ogre__Real_t_t_t__const_iterator", "std::map< Ogre::Real,Ogre::Real,std::less< Ogre::Real >,std::allocator< std::pair< Ogre::Real const,Ogre::Real > > >::const_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_Ogre__MovableObject_p_Ogre__MovableObject_p_t = {"_p_std__pairT_Ogre__MovableObject_p_Ogre__MovableObject_p_t", "std::pair< Ogre::MovableObject *,Ogre::MovableObject * > *|Ogre::SceneQueryMovableObjectPair *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_Ogre__MovableObject_p_Ogre__WorldFragment_p_t = {"_p_std__pairT_Ogre__MovableObject_p_Ogre__WorldFragment_p_t", "std::pair< Ogre::MovableObject *,Ogre::SceneQuery::WorldFragment * > *|Ogre::SceneQueryMovableObjectWorldFragmentPair *|std::pair< Ogre::MovableObject *,Ogre::WorldFragment * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *|Ogre::_StringBase *|Ogre::String *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Ogre__Vector2_std__allocatorT_Ogre__Vector2_t_t = {"_p_std__vectorT_Ogre__Vector2_std__allocatorT_Ogre__Vector2_t_t", "Procedural::PointList *|std::vector< Ogre::Vector2,std::allocator< Ogre::Vector2 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Ogre__Vector3_std__allocatorT_Ogre__Vector3_t_t = {"_p_std__vectorT_Ogre__Vector3_std__allocatorT_Ogre__Vector3_t_t", "std::vector< Ogre::Vector3,std::allocator< Ogre::Vector3 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Vertex_std__allocatorT_Vertex_t_t = {"_p_std__vectorT_Vertex_std__allocatorT_Vertex_t_t", "std::vector< Vertex,std::allocator< Vertex > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_int_std__allocatorT_int_t_t = {"_p_std__vectorT_int_std__allocatorT_int_t_t", "std::vector< int,std::allocator< int > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_stdext__hash_compareT_Ogre___StringBase_std__lessT_Ogre___StringBase_t_t = {"_p_stdext__hash_compareT_Ogre___StringBase_std__lessT_Ogre___StringBase_t_t", "Ogre::_StringHash *|stdext::hash_compare< Ogre::_StringBase,std::less< Ogre::_StringBase > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unicode_char = {"_p_unicode_char", "unicode_char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "Ogre::uchar *|unsigned char *|Ogre::uint8 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "Ogre::RGBA *|Ogre::uint32 *|unsigned int *|Ogre::uint *|Ogre::ARGB *|Ogre::BGRA *|Ogre::ABGR *|Ogre::PageID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "Ogre::ulong *|unsigned long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "Ogre::uint64 *|unsigned long long *|Ogre::ResourceHandle *|Ogre::BackgroundProcessTicket *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "Ogre::uint16 *|unsigned short *|Ogre::ushort *|Ogre::SceneTypeMask *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_utf32string = {"_p_utf32string", "utf32string *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_z_stream_s = {"_p_z_stream_s", "z_stream_s *|z_stream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_zzip_dir = {"_p_zzip_dir", "zzip_dir *|ZZIP_DIR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_zzip_file = {"_p_zzip_file", "zzip_file *|ZZIP_FILE *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_AliasTextureIterator,
  &_swigt__p_AnimationIterator,
  &_swigt__p_ArchiveMapIterator,
  &_swigt__p_AutoConstantIterator,
  &_swigt__p_AutoConstantList,
  &_swigt__p_BatchInstanceIterator,
  &_swigt__p_BatchInstanceMap,
  &_swigt__p_BindingIndexMap,
  &_swigt__p_BoneAssignmentIterator,
  &_swigt__p_BoneBlendMask,
  &_swigt__p_BoneHandleMap,
  &_swigt__p_BoneIterator,
  &_swigt__p_BoneList,
  &_swigt__p_BoundSufaceList,
  &_swigt__p_Box,
  &_swigt__p_CameraIterator,
  &_swigt__p_CameraList,
  &_swigt__p_ChildContainerIterator,
  &_swigt__p_ChildContainerMap,
  &_swigt__p_ChildIterator,
  &_swigt__p_ChildMap,
  &_swigt__p_ChildNodeIterator,
  &_swigt__p_ChildNodeMap,
  &_swigt__p_ChildObjectList,
  &_swigt__p_ChildObjectListIterator,
  &_swigt__p_CodePoint,
  &_swigt__p_CodePointRange,
  &_swigt__p_CodePointRangeList,
  &_swigt__p_CodecDataPtr,
  &_swigt__p_CodecIterator,
  &_swigt__p_CompiledState,
  &_swigt__p_ConstChildNodeIterator,
  &_swigt__p_ConstNormalsIterator,
  &_swigt__p_ConstObjectIterator,
  &_swigt__p_ConstPoseIterator,
  &_swigt__p_ConstPoseRefIterator,
  &_swigt__p_ConstPriorityMapIterator,
  &_swigt__p_ConstQueueGroupIterator,
  &_swigt__p_ConstTerrainIterator,
  &_swigt__p_ConstTextureUnitStateIterator,
  &_swigt__p_ConstVertexOffsetIterator,
  &_swigt__p_ContentCollectionFactoryMap,
  &_swigt__p_ContentCollectionList,
  &_swigt__p_ContentFactoryMap,
  &_swigt__p_ContentList,
  &_swigt__p_CornerEnum,
  &_swigt__p_DecodeResult,
  &_swigt__p_Edge,
  &_swigt__p_EdgeGroupList,
  &_swigt__p_EdgeList,
  &_swigt__p_EdgeMap,
  &_swigt__p_EffectMap,
  &_swigt__p_ElementList,
  &_swigt__p_ElementMap,
  &_swigt__p_EntitySet,
  &_swigt__p_ErrorList,
  &_swigt__p_ErrorPtr,
  &_swigt__p_FactoryMap,
  &_swigt__p_GPUDeviceNameRuleIterator,
  &_swigt__p_GPUDeviceNameRuleList,
  &_swigt__p_GPUVendorRuleIterator,
  &_swigt__p_GPUVendorRuleList,
  &_swigt__p_GpuSharedParamUsageList,
  &_swigt__p_HardwareAnimationDataList,
  &_swigt__p_IdMap,
  &_swigt__p_IlluminationPassIterator,
  &_swigt__p_IndexMap,
  &_swigt__p_IndexRemapList,
  &_swigt__p_InstanceBatchIterator,
  &_swigt__p_InstanceBatchMapIterator,
  &_swigt__p_InstanceIterator,
  &_swigt__p_InstancedEntityVec,
  &_swigt__p_Instances,
  &_swigt__p_Intp,
  &_swigt__p_LODFaceList,
  &_swigt__p_LayerInstanceList,
  &_swigt__p_LinkedSkeletonAnimSourceIterator,
  &_swigt__p_LinkedSkeletonAnimSourceList,
  &_swigt__p_LocationList,
  &_swigt__p_LodLevelList,
  &_swigt__p_LodValueIterator,
  &_swigt__p_LodValueList,
  &_swigt__p_MeshLodUsageList,
  &_swigt__p_MetaDataIterator,
  &_swigt__p_MetaDataList,
  &_swigt__p_Microcode,
  &_swigt__p_MicrocodeMap,
  &_swigt__p_MovableObjectFactoryIterator,
  &_swigt__p_MovableObjectIterator,
  &_swigt__p_NodeIterator,
  &_swigt__p_NodeList,
  &_swigt__p_NodeTrackIterator,
  &_swigt__p_NodeTrackList,
  &_swigt__p_NormalsIterator,
  &_swigt__p_NormalsMap,
  &_swigt__p_NumericTrackIterator,
  &_swigt__p_NumericTrackList,
  &_swigt__p_ObjectIterator,
  &_swigt__p_ObjectMap,
  &_swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_ANIMATION_t_t,
  &_swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GENERAL_t_t,
  &_swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_t_t,
  &_swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RENDERSYS_t_t,
  &_swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RESOURCE_t_t,
  &_swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_CONTROL_t_t,
  &_swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_OBJECTS_t_t,
  &_swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCRIPTING_t_t,
  &_swigt__p_Ogre__AnimationStateIterator,
  &_swigt__p_Ogre__AxisAlignedBox,
  &_swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_ANIMATION_t,
  &_swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GENERAL_t,
  &_swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_t,
  &_swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RENDERSYS_t,
  &_swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RESOURCE_t,
  &_swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_CONTROL_t,
  &_swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_OBJECTS_t,
  &_swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCRIPTING_t,
  &_swigt__p_Ogre__ConstAnimationStateIterator,
  &_swigt__p_Ogre__ConstEnabledAnimationStateIterator,
  &_swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__GpuConstantDefinition_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuConstantDefinition_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__ConstShadowTextureConfigIterator,
  &_swigt__p_Ogre__HashedVectorT_Ogre__Light_p_t,
  &_swigt__p_Ogre__ManualObject,
  &_swigt__p_Ogre__Matrix4,
  &_swigt__p_Ogre__MeshPtr,
  &_swigt__p_Ogre__MovablePlane,
  &_swigt__p_Ogre__Plane,
  &_swigt__p_Ogre__Quaternion,
  &_swigt__p_Ogre__Radian,
  &_swigt__p_Ogre__Rectangle,
  &_swigt__p_Ogre__SharedPtrT_Ogre__AbstractNode_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__AnimableValue_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__ConcreteNode_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__ControllerFunctionT_float_t_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__ControllerValueT_float_t_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__DataStream_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__GpuLogicalBufferStruct_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__GpuNamedConstants_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__GpuSharedParameters_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__MemoryDataStream_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__RenderToVertexBuffer_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__Resource_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__ScriptToken_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__ShadowCameraSetup_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__TerrainMaterialGenerator_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__listT_Ogre__DataStreamPtr_Ogre__STLAllocatorT_Ogre__DataStreamPtr_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__ScriptTokenPtr_Ogre__STLAllocatorT_Ogre__ScriptTokenPtr_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__SimpleSpline,
  &_swigt__p_Ogre__TRectT_float_t,
  &_swigt__p_Ogre__TRectT_long_t,
  &_swigt__p_Ogre__UTFString,
  &_swigt__p_Ogre__Vector2,
  &_swigt__p_Ogre__Vector3,
  &_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__RenderQueueInvocation_p_Ogre__STLAllocatorT_Ogre__RenderQueueInvocation_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__VertexBoneAssignment_s,
  &_swigt__p_Ogre___ConfigOption,
  &_swigt__p_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__listT_Ogre__AnimationState_p_Ogre__STLAllocatorT_Ogre__AnimationState_p_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__listT_Ogre__DataStreamPtr_Ogre__STLAllocatorT_Ogre__DataStreamPtr_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__listT_Ogre__MovableObject_p_Ogre__STLAllocatorT_Ogre__MovableObject_p_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__listT_Ogre__SceneQueryMovableObjectPair_Ogre__STLAllocatorT_Ogre__SceneQueryMovableObjectPair_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__listT_Ogre__SceneQueryMovableObjectWorldFragmentPair_Ogre__STLAllocatorT_Ogre__SceneQueryMovableObjectWorldFragmentPair_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__listT_Ogre__WorldFragment_p_Ogre__STLAllocatorT_Ogre__WorldFragment_p_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_Ogre__String_Ogre__AnimationState_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__AnimationState_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_Ogre__String_Ogre__ConfigOption_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ConfigOption_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_Ogre__String_Ogre__GpuConstantDefinition_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuConstantDefinition_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_Ogre__String_Ogre__ParamCommand_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParamCommand_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_Ogre__String_Ogre__ParamDictionary_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParamDictionary_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_Ogre__String_Ogre__RenderTarget_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__RenderTarget_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_Ogre__String_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_Ogre__String_bool_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_bool_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_Ogre__uint16_Ogre__DepthBufferVec_std__lessT_Ogre__uint16_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint16_const_Ogre__DepthBufferVec_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_size_t_Ogre__GpuLogicalIndexUse_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__GpuLogicalIndexUse_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__multimapT_Ogre__uchar_Ogre__RenderTarget_p_std__lessT_Ogre__uchar_t_Ogre__STLAllocatorT_std__pairT_Ogre__uchar_const_Ogre__RenderTarget_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__DepthBuffer_p_Ogre__STLAllocatorT_Ogre__DepthBuffer_p_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__HardwareBuffer__Usage_Ogre__STLAllocatorT_Ogre__HardwareBuffer__Usage_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__IlluminationPass_p_Ogre__STLAllocatorT_Ogre__IlluminationPass_p_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__Image_const_p_Ogre__STLAllocatorT_Ogre__Image_const_p_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__Image_p_Ogre__STLAllocatorT_Ogre__Image_p_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__ParameterDef_Ogre__STLAllocatorT_Ogre__ParameterDef_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__PixelFormat_Ogre__STLAllocatorT_Ogre__PixelFormat_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__PlaneBoundedVolume_Ogre__STLAllocatorT_Ogre__PlaneBoundedVolume_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__Pose_p_Ogre__STLAllocatorT_Ogre__Pose_p_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__RaySceneQueryResultEntry_Ogre__STLAllocatorT_Ogre__RaySceneQueryResultEntry_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__RenderQueueInvocation_p_Ogre__STLAllocatorT_Ogre__RenderQueueInvocation_p_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__RenderSystem_p_Ogre__STLAllocatorT_Ogre__RenderSystem_p_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__RenderWindowDescription_Ogre__STLAllocatorT_Ogre__RenderWindowDescription_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__RenderWindow_p_Ogre__STLAllocatorT_Ogre__RenderWindow_p_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__ScriptTokenPtr_Ogre__STLAllocatorT_Ogre__ScriptTokenPtr_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__ShadowTextureConfig_Ogre__STLAllocatorT_Ogre__ShadowTextureConfig_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__TerrainLayerBlendMap_p_Ogre__STLAllocatorT_Ogre__TerrainLayerBlendMap_p_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__TerrainLayerSamplerElement_Ogre__STLAllocatorT_Ogre__TerrainLayerSamplerElement_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__TerrainLayerSampler_Ogre__STLAllocatorT_Ogre__TerrainLayerSampler_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__TexturePtr_Ogre__STLAllocatorT_Ogre__TexturePtr_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_float_Ogre__STLAllocatorT_float_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_int_Ogre__STLAllocatorT_int_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_OptimalAdjustFactorList,
  &_swigt__p_OptimisedSubMeshGeometryList,
  &_swigt__p_Overlay2DElementsIterator,
  &_swigt__p_OverlayContainerList,
  &_swigt__p_OverlayMap,
  &_swigt__p_OverlayMapIterator,
  &_swigt__p_PageMap,
  &_swigt__p_ParticleAffectorFactoryIterator,
  &_swigt__p_ParticleAffectorFactoryMap,
  &_swigt__p_ParticleEmitterFactoryIterator,
  &_swigt__p_ParticleEmitterFactoryMap,
  &_swigt__p_ParticleRendererFactoryIterator,
  &_swigt__p_ParticleSystemRendererFactoryMap,
  &_swigt__p_ParticleSystemTemplateIterator,
  &_swigt__p_ParticleTemplateMap,
  &_swigt__p_PassIterator,
  &_swigt__p_PassSet,
  &_swigt__p_Passes,
  &_swigt__p_PlaneList,
  &_swigt__p_PluginInstanceList,
  &_swigt__p_PluginLibList,
  &_swigt__p_PolygonList,
  &_swigt__p_PoseIterator,
  &_swigt__p_PoseRefIterator,
  &_swigt__p_PoseRefList,
  &_swigt__p_PriorityMap,
  &_swigt__p_PriorityMapIterator,
  &_swigt__p_Procedural__BoxGenerator,
  &_swigt__p_Procedural__CapsuleGenerator,
  &_swigt__p_Procedural__CatmullRomSpline2,
  &_swigt__p_Procedural__CatmullRomSpline3,
  &_swigt__p_Procedural__Circle,
  &_swigt__p_Procedural__CircleShape,
  &_swigt__p_Procedural__ConeGenerator,
  &_swigt__p_Procedural__CubicHermiteSpline2,
  &_swigt__p_Procedural__CubicHermiteSpline3,
  &_swigt__p_Procedural__CylinderGenerator,
  &_swigt__p_Procedural__Extruder,
  &_swigt__p_Procedural__IcoSphereGenerator,
  &_swigt__p_Procedural__KochanekBartelsSpline2,
  &_swigt__p_Procedural__Lathe,
  &_swigt__p_Procedural__Line,
  &_swigt__p_Procedural__Line2D,
  &_swigt__p_Procedural__LinePath,
  &_swigt__p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t,
  &_swigt__p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t,
  &_swigt__p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t,
  &_swigt__p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t,
  &_swigt__p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t,
  &_swigt__p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t,
  &_swigt__p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t,
  &_swigt__p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t,
  &_swigt__p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t,
  &_swigt__p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t,
  &_swigt__p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t,
  &_swigt__p_Procedural__MultiShape,
  &_swigt__p_Procedural__Path,
  &_swigt__p_Procedural__Plane,
  &_swigt__p_Procedural__PlaneGenerator,
  &_swigt__p_Procedural__RectangleShape,
  &_swigt__p_Procedural__Root,
  &_swigt__p_Procedural__RoundedBoxGenerator,
  &_swigt__p_Procedural__RoundedCornerSpline2,
  &_swigt__p_Procedural__RoundedCornerSpline3,
  &_swigt__p_Procedural__Segment2D,
  &_swigt__p_Procedural__Shape,
  &_swigt__p_Procedural__SphereGenerator,
  &_swigt__p_Procedural__TorusGenerator,
  &_swigt__p_Procedural__TorusKnotGenerator,
  &_swigt__p_Procedural__Track,
  &_swigt__p_Procedural__TriangleBuffer,
  &_swigt__p_Procedural__Triangulator,
  &_swigt__p_Procedural__TubeGenerator,
  &_swigt__p_Procedural__Utils,
  &_swigt__p_ProfileList,
  &_swigt__p_QuadMaterialMap,
  &_swigt__p_QueueGroupIterator,
  &_swigt__p_QueuedGeometryList,
  &_swigt__p_QueuedSubMeshList,
  &_swigt__p_QueuedSubMeshOriginList,
  &_swigt__p_RealVector,
  &_swigt__p_Rect,
  &_swigt__p_RegionIterator,
  &_swigt__p_RegionMap,
  &_swigt__p_RenderOperationVector,
  &_swigt__p_RenderSystemOpPair,
  &_swigt__p_RenderSystemOpPairs,
  &_swigt__p_RenderTargetIterator,
  &_swigt__p_RequestID,
  &_swigt__p_ResourceCreateOrRetrieveResult,
  &_swigt__p_ResourceDeclarationList,
  &_swigt__p_ResourceHandleMap,
  &_swigt__p_ResourceManagerIterator,
  &_swigt__p_ResourceManagerMap,
  &_swigt__p_ResourceMap,
  &_swigt__p_ResourceMapIterator,
  &_swigt__p_ResourceWithGroupMap,
  &_swigt__p_SceneManagerIterator,
  &_swigt__p_SchemeHardwareAnimMap,
  &_swigt__p_SectionIterator,
  &_swigt__p_SectionList,
  &_swigt__p_SectionMap,
  &_swigt__p_SettingsBySection,
  &_swigt__p_SettingsIterator,
  &_swigt__p_SettingsMultiMap,
  &_swigt__p_ShaderProfiles,
  &_swigt__p_ShadowRenderableList,
  &_swigt__p_ShadowRenderableListIterator,
  &_swigt__p_SharedParametersMap,
  &_swigt__p_SplitPointList,
  &_swigt__p_StrStreamType,
  &_swigt__p_StrategyMap,
  &_swigt__p_SubMeshGeometryLookup,
  &_swigt__p_SubMeshIterator,
  &_swigt__p_SubMeshList,
  &_swigt__p_SubMeshLodGeometryLinkList,
  &_swigt__p_SubMeshNameMap,
  &_swigt__p_SyntaxCodes,
  &_swigt__p_TargetPassIterator,
  &_swigt__p_TargetPasses,
  &_swigt__p_TechniqueIterator,
  &_swigt__p_Techniques,
  &_swigt__p_TemplateIterator,
  &_swigt__p_TerrainIterator,
  &_swigt__p_TerrainList,
  &_swigt__p_TerrainSlotMap,
  &_swigt__p_TextureDefinitionIterator,
  &_swigt__p_TextureDefinitions,
  &_swigt__p_TextureUnitStateIterator,
  &_swigt__p_TrackHandleList,
  &_swigt__p_TriangleFaceNormalList,
  &_swigt__p_TriangleLightFacingList,
  &_swigt__p_TriangleList,
  &_swigt__p_UVRect,
  &_swigt__p_UniqueTextureSet,
  &_swigt__p_VertexBoneAssignmentList,
  &_swigt__p_VertexBufferBindingMap,
  &_swigt__p_VertexElementList,
  &_swigt__p_VertexList,
  &_swigt__p_VertexOffsetIterator,
  &_swigt__p_VertexOffsetMap,
  &_swigt__p_VertexSplit,
  &_swigt__p_VertexSplits,
  &_swigt__p_VertexTrackIterator,
  &_swigt__p_VertexTrackList,
  &_swigt__p_WindowEventListeners,
  &_swigt__p_Windows,
  &_swigt__p_WorldMap,
  &_swigt__p_WorldSectionFactoryMap,
  &_swigt__p__zzip_plugin_io,
  &_swigt__p_char,
  &_swigt__p_code_point,
  &_swigt__p_const_iterator,
  &_swigt__p_const_reverse_iterator,
  &_swigt__p_dstring,
  &_swigt__p_float,
  &_swigt__p_int,
  &_swigt__p_iterator,
  &_swigt__p_long_long,
  &_swigt__p_reverse_iterator,
  &_swigt__p_short,
  &_swigt__p_size_type,
  &_swigt__p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_std__mapT_Ogre__Real_Ogre__Real_std__lessT_Ogre__Real_t_std__allocatorT_std__pairT_Ogre__Real_const_Ogre__Real_t_t_t__const_iterator,
  &_swigt__p_std__pairT_Ogre__MovableObject_p_Ogre__MovableObject_p_t,
  &_swigt__p_std__pairT_Ogre__MovableObject_p_Ogre__WorldFragment_p_t,
  &_swigt__p_std__string,
  &_swigt__p_std__vectorT_Ogre__Vector2_std__allocatorT_Ogre__Vector2_t_t,
  &_swigt__p_std__vectorT_Ogre__Vector3_std__allocatorT_Ogre__Vector3_t_t,
  &_swigt__p_std__vectorT_Vertex_std__allocatorT_Vertex_t_t,
  &_swigt__p_std__vectorT_int_std__allocatorT_int_t_t,
  &_swigt__p_stdext__hash_compareT_Ogre___StringBase_std__lessT_Ogre___StringBase_t_t,
  &_swigt__p_unicode_char,
  &_swigt__p_unsigned_char,
  &_swigt__p_unsigned_int,
  &_swigt__p_unsigned_long,
  &_swigt__p_unsigned_long_long,
  &_swigt__p_unsigned_short,
  &_swigt__p_utf32string,
  &_swigt__p_value_type,
  &_swigt__p_z_stream_s,
  &_swigt__p_zzip_dir,
  &_swigt__p_zzip_file,
};

static swig_cast_info _swigc__p_AliasTextureIterator[] = {  {&_swigt__p_AliasTextureIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AnimationIterator[] = {  {&_swigt__p_AnimationIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ArchiveMapIterator[] = {  {&_swigt__p_ArchiveMapIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AutoConstantIterator[] = {  {&_swigt__p_AutoConstantIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_AutoConstantList[] = {  {&_swigt__p_AutoConstantList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BatchInstanceIterator[] = {  {&_swigt__p_BatchInstanceIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BatchInstanceMap[] = {  {&_swigt__p_BatchInstanceMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BindingIndexMap[] = {  {&_swigt__p_BindingIndexMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BoneAssignmentIterator[] = {  {&_swigt__p_BoneAssignmentIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BoneBlendMask[] = {  {&_swigt__p_BoneBlendMask, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BoneHandleMap[] = {  {&_swigt__p_BoneHandleMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BoneIterator[] = {  {&_swigt__p_BoneIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BoneList[] = {  {&_swigt__p_BoneList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_BoundSufaceList[] = {  {&_swigt__p_BoundSufaceList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Box[] = {  {&_swigt__p_Box, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraIterator[] = {  {&_swigt__p_CameraIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CameraList[] = {  {&_swigt__p_CameraList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ChildContainerIterator[] = {  {&_swigt__p_ChildContainerIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ChildContainerMap[] = {  {&_swigt__p_ChildContainerMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ChildIterator[] = {  {&_swigt__p_ChildIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ChildMap[] = {  {&_swigt__p_ChildMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ChildNodeIterator[] = {  {&_swigt__p_ChildNodeIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ChildNodeMap[] = {  {&_swigt__p_ChildNodeMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ChildObjectList[] = {  {&_swigt__p_ChildObjectList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ChildObjectListIterator[] = {  {&_swigt__p_ChildObjectListIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CodePoint[] = {  {&_swigt__p_CodePoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CodePointRange[] = {  {&_swigt__p_CodePointRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CodePointRangeList[] = {  {&_swigt__p_CodePointRangeList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CodecDataPtr[] = {  {&_swigt__p_CodecDataPtr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CodecIterator[] = {  {&_swigt__p_CodecIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CompiledState[] = {  {&_swigt__p_CompiledState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstChildNodeIterator[] = {  {&_swigt__p_ConstChildNodeIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstNormalsIterator[] = {  {&_swigt__p_ConstNormalsIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstObjectIterator[] = {  {&_swigt__p_ConstObjectIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstPoseIterator[] = {  {&_swigt__p_ConstPoseIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstPoseRefIterator[] = {  {&_swigt__p_ConstPoseRefIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstPriorityMapIterator[] = {  {&_swigt__p_ConstPriorityMapIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstQueueGroupIterator[] = {  {&_swigt__p_ConstQueueGroupIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstTerrainIterator[] = {  {&_swigt__p_ConstTerrainIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstTextureUnitStateIterator[] = {  {&_swigt__p_ConstTextureUnitStateIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstVertexOffsetIterator[] = {  {&_swigt__p_ConstVertexOffsetIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ContentCollectionFactoryMap[] = {  {&_swigt__p_ContentCollectionFactoryMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ContentCollectionList[] = {  {&_swigt__p_ContentCollectionList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ContentFactoryMap[] = {  {&_swigt__p_ContentFactoryMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ContentList[] = {  {&_swigt__p_ContentList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_CornerEnum[] = {  {&_swigt__p_CornerEnum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DecodeResult[] = {  {&_swigt__p_DecodeResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Edge[] = {  {&_swigt__p_Edge, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EdgeGroupList[] = {  {&_swigt__p_EdgeGroupList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EdgeList[] = {  {&_swigt__p_EdgeList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EdgeMap[] = {  {&_swigt__p_EdgeMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EffectMap[] = {  {&_swigt__p_EffectMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ElementList[] = {  {&_swigt__p_ElementList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ElementMap[] = {  {&_swigt__p_ElementMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_EntitySet[] = {  {&_swigt__p_EntitySet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ErrorList[] = {  {&_swigt__p_ErrorList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ErrorPtr[] = {  {&_swigt__p_ErrorPtr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FactoryMap[] = {  {&_swigt__p_FactoryMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GPUDeviceNameRuleIterator[] = {  {&_swigt__p_GPUDeviceNameRuleIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GPUDeviceNameRuleList[] = {  {&_swigt__p_GPUDeviceNameRuleList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GPUVendorRuleIterator[] = {  {&_swigt__p_GPUVendorRuleIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GPUVendorRuleList[] = {  {&_swigt__p_GPUVendorRuleList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_GpuSharedParamUsageList[] = {  {&_swigt__p_GpuSharedParamUsageList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_HardwareAnimationDataList[] = {  {&_swigt__p_HardwareAnimationDataList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IdMap[] = {  {&_swigt__p_IdMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IlluminationPassIterator[] = {  {&_swigt__p_IlluminationPassIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IndexMap[] = {  {&_swigt__p_IndexMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IndexRemapList[] = {  {&_swigt__p_IndexRemapList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InstanceBatchIterator[] = {  {&_swigt__p_InstanceBatchIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InstanceBatchMapIterator[] = {  {&_swigt__p_InstanceBatchMapIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InstanceIterator[] = {  {&_swigt__p_InstanceIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_InstancedEntityVec[] = {  {&_swigt__p_InstancedEntityVec, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Instances[] = {  {&_swigt__p_Instances, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LODFaceList[] = {  {&_swigt__p_LODFaceList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LayerInstanceList[] = {  {&_swigt__p_LayerInstanceList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LinkedSkeletonAnimSourceIterator[] = {  {&_swigt__p_LinkedSkeletonAnimSourceIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LinkedSkeletonAnimSourceList[] = {  {&_swigt__p_LinkedSkeletonAnimSourceList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LocationList[] = {  {&_swigt__p_LocationList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LodLevelList[] = {  {&_swigt__p_LodLevelList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LodValueIterator[] = {  {&_swigt__p_LodValueIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LodValueList[] = {  {&_swigt__p_LodValueList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MeshLodUsageList[] = {  {&_swigt__p_MeshLodUsageList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MetaDataIterator[] = {  {&_swigt__p_MetaDataIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MetaDataList[] = {  {&_swigt__p_MetaDataList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Microcode[] = {  {&_swigt__p_Microcode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MicrocodeMap[] = {  {&_swigt__p_MicrocodeMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MovableObjectFactoryIterator[] = {  {&_swigt__p_MovableObjectFactoryIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_MovableObjectIterator[] = {  {&_swigt__p_MovableObjectIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NodeIterator[] = {  {&_swigt__p_NodeIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NodeList[] = {  {&_swigt__p_NodeList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NodeTrackIterator[] = {  {&_swigt__p_NodeTrackIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NodeTrackList[] = {  {&_swigt__p_NodeTrackList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NormalsIterator[] = {  {&_swigt__p_NormalsIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NormalsMap[] = {  {&_swigt__p_NormalsMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NumericTrackIterator[] = {  {&_swigt__p_NumericTrackIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_NumericTrackList[] = {  {&_swigt__p_NumericTrackList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ObjectIterator[] = {  {&_swigt__p_ObjectIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ObjectMap[] = {  {&_swigt__p_ObjectMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_ANIMATION_t_t[] = {  {&_swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_ANIMATION_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GENERAL_t_t[] = {  {&_swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GENERAL_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_t_t[] = {  {&_swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RENDERSYS_t_t[] = {  {&_swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RENDERSYS_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RESOURCE_t_t[] = {  {&_swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RESOURCE_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_CONTROL_t_t[] = {  {&_swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_CONTROL_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_OBJECTS_t_t[] = {  {&_swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_OBJECTS_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCRIPTING_t_t[] = {  {&_swigt__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCRIPTING_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AnimationStateIterator[] = {  {&_swigt__p_Ogre__AnimationStateIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AxisAlignedBox[] = {  {&_swigt__p_Ogre__AxisAlignedBox, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_ANIMATION_t[] = {  {&_swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_ANIMATION_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GENERAL_t[] = {  {&_swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GENERAL_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_t[] = {  {&_swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RENDERSYS_t[] = {  {&_swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RENDERSYS_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RESOURCE_t[] = {  {&_swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RESOURCE_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_CONTROL_t[] = {  {&_swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_CONTROL_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_OBJECTS_t[] = {  {&_swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_OBJECTS_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCRIPTING_t[] = {  {&_swigt__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCRIPTING_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConstAnimationStateIterator[] = {  {&_swigt__p_Ogre__ConstAnimationStateIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConstEnabledAnimationStateIterator[] = {  {&_swigt__p_Ogre__ConstEnabledAnimationStateIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__GpuConstantDefinition_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuConstantDefinition_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__GpuConstantDefinition_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuConstantDefinition_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConstShadowTextureConfigIterator[] = {  {&_swigt__p_Ogre__ConstShadowTextureConfigIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__HashedVectorT_Ogre__Light_p_t[] = {  {&_swigt__p_Ogre__HashedVectorT_Ogre__Light_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ManualObject[] = {  {&_swigt__p_Ogre__ManualObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Matrix4[] = {  {&_swigt__p_Ogre__Matrix4, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MeshPtr[] = {  {&_swigt__p_Ogre__MeshPtr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MovablePlane[] = {{&_swigt__p_Ogre__MovablePlane, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Plane[] = {  {&_swigt__p_Ogre__MovablePlane, _p_Ogre__MovablePlaneTo_p_Ogre__Plane, 0, 0},  {&_swigt__p_Ogre__Plane, 0, 0, 0},  {&_swigt__p_Procedural__Plane, _p_Procedural__PlaneTo_p_Ogre__Plane, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Quaternion[] = {  {&_swigt__p_Ogre__Quaternion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Radian[] = {  {&_swigt__p_Ogre__Radian, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Rectangle[] = {  {&_swigt__p_Ogre__Rectangle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__AbstractNode_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__AbstractNode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__AnimableValue_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__AnimableValue_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__ConcreteNode_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__ConcreteNode_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__ControllerFunctionT_float_t_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__ControllerFunctionT_float_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__ControllerValueT_float_t_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__ControllerValueT_float_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__DataStream_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__DataStream_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__GpuLogicalBufferStruct_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__GpuLogicalBufferStruct_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__GpuNamedConstants_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__GpuNamedConstants_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__GpuSharedParameters_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__GpuSharedParameters_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__MemoryDataStream_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__MemoryDataStream_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__RenderToVertexBuffer_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__RenderToVertexBuffer_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__Resource_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__Resource_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__ScriptToken_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__ScriptToken_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__ShadowCameraSetup_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__ShadowCameraSetup_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__TerrainMaterialGenerator_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__TerrainMaterialGenerator_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__listT_Ogre__DataStreamPtr_Ogre__STLAllocatorT_Ogre__DataStreamPtr_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__listT_Ogre__DataStreamPtr_Ogre__STLAllocatorT_Ogre__DataStreamPtr_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__ScriptTokenPtr_Ogre__STLAllocatorT_Ogre__ScriptTokenPtr_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__ScriptTokenPtr_Ogre__STLAllocatorT_Ogre__ScriptTokenPtr_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SimpleSpline[] = {  {&_swigt__p_Ogre__SimpleSpline, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TRectT_float_t[] = {  {&_swigt__p_Ogre__TRectT_float_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TRectT_long_t[] = {  {&_swigt__p_Ogre__TRectT_long_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__UTFString[] = {  {&_swigt__p_Ogre__UTFString, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Vector2[] = {  {&_swigt__p_Ogre__Vector2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Vector3[] = {  {&_swigt__p_Ogre__Vector3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__RenderQueueInvocation_p_Ogre__STLAllocatorT_Ogre__RenderQueueInvocation_p_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__RenderQueueInvocation_p_Ogre__STLAllocatorT_Ogre__RenderQueueInvocation_p_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VertexBoneAssignment_s[] = {  {&_swigt__p_Ogre__VertexBoneAssignment_s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre___ConfigOption[] = {  {&_swigt__p_Ogre___ConfigOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__listT_Ogre__AnimationState_p_Ogre__STLAllocatorT_Ogre__AnimationState_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__listT_Ogre__AnimationState_p_Ogre__STLAllocatorT_Ogre__AnimationState_p_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__listT_Ogre__DataStreamPtr_Ogre__STLAllocatorT_Ogre__DataStreamPtr_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__listT_Ogre__DataStreamPtr_Ogre__STLAllocatorT_Ogre__DataStreamPtr_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__listT_Ogre__MovableObject_p_Ogre__STLAllocatorT_Ogre__MovableObject_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__listT_Ogre__MovableObject_p_Ogre__STLAllocatorT_Ogre__MovableObject_p_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__listT_Ogre__SceneQueryMovableObjectPair_Ogre__STLAllocatorT_Ogre__SceneQueryMovableObjectPair_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__listT_Ogre__SceneQueryMovableObjectPair_Ogre__STLAllocatorT_Ogre__SceneQueryMovableObjectPair_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__listT_Ogre__SceneQueryMovableObjectWorldFragmentPair_Ogre__STLAllocatorT_Ogre__SceneQueryMovableObjectWorldFragmentPair_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__listT_Ogre__SceneQueryMovableObjectWorldFragmentPair_Ogre__STLAllocatorT_Ogre__SceneQueryMovableObjectWorldFragmentPair_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__listT_Ogre__WorldFragment_p_Ogre__STLAllocatorT_Ogre__WorldFragment_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__listT_Ogre__WorldFragment_p_Ogre__STLAllocatorT_Ogre__WorldFragment_p_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__mapT_Ogre__String_Ogre__AnimationState_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__AnimationState_p_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_Ogre__String_Ogre__AnimationState_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__AnimationState_p_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__mapT_Ogre__String_Ogre__ConfigOption_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ConfigOption_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_Ogre__String_Ogre__ConfigOption_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ConfigOption_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__mapT_Ogre__String_Ogre__GpuConstantDefinition_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuConstantDefinition_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_Ogre__String_Ogre__GpuConstantDefinition_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuConstantDefinition_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__mapT_Ogre__String_Ogre__ParamCommand_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParamCommand_p_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_Ogre__String_Ogre__ParamCommand_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParamCommand_p_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__mapT_Ogre__String_Ogre__ParamDictionary_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParamDictionary_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_Ogre__String_Ogre__ParamDictionary_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParamDictionary_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__mapT_Ogre__String_Ogre__RenderTarget_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__RenderTarget_p_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_Ogre__String_Ogre__RenderTarget_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__RenderTarget_p_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__mapT_Ogre__String_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_Ogre__String_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__mapT_Ogre__String_bool_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_bool_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_Ogre__String_bool_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_bool_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__mapT_Ogre__uint16_Ogre__DepthBufferVec_std__lessT_Ogre__uint16_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint16_const_Ogre__DepthBufferVec_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_Ogre__uint16_Ogre__DepthBufferVec_std__lessT_Ogre__uint16_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint16_const_Ogre__DepthBufferVec_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__mapT_size_t_Ogre__GpuLogicalIndexUse_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__GpuLogicalIndexUse_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_size_t_Ogre__GpuLogicalIndexUse_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__GpuLogicalIndexUse_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__multimapT_Ogre__uchar_Ogre__RenderTarget_p_std__lessT_Ogre__uchar_t_Ogre__STLAllocatorT_std__pairT_Ogre__uchar_const_Ogre__RenderTarget_p_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__multimapT_Ogre__uchar_Ogre__RenderTarget_p_std__lessT_Ogre__uchar_t_Ogre__STLAllocatorT_std__pairT_Ogre__uchar_const_Ogre__RenderTarget_p_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__DepthBuffer_p_Ogre__STLAllocatorT_Ogre__DepthBuffer_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__DepthBuffer_p_Ogre__STLAllocatorT_Ogre__DepthBuffer_p_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__HardwareBuffer__Usage_Ogre__STLAllocatorT_Ogre__HardwareBuffer__Usage_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__HardwareBuffer__Usage_Ogre__STLAllocatorT_Ogre__HardwareBuffer__Usage_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__IlluminationPass_p_Ogre__STLAllocatorT_Ogre__IlluminationPass_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__IlluminationPass_p_Ogre__STLAllocatorT_Ogre__IlluminationPass_p_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__Image_const_p_Ogre__STLAllocatorT_Ogre__Image_const_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__Image_const_p_Ogre__STLAllocatorT_Ogre__Image_const_p_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__Image_p_Ogre__STLAllocatorT_Ogre__Image_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__Image_p_Ogre__STLAllocatorT_Ogre__Image_p_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__ParameterDef_Ogre__STLAllocatorT_Ogre__ParameterDef_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__ParameterDef_Ogre__STLAllocatorT_Ogre__ParameterDef_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__PixelFormat_Ogre__STLAllocatorT_Ogre__PixelFormat_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__PixelFormat_Ogre__STLAllocatorT_Ogre__PixelFormat_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__PlaneBoundedVolume_Ogre__STLAllocatorT_Ogre__PlaneBoundedVolume_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__PlaneBoundedVolume_Ogre__STLAllocatorT_Ogre__PlaneBoundedVolume_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__Pose_p_Ogre__STLAllocatorT_Ogre__Pose_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__Pose_p_Ogre__STLAllocatorT_Ogre__Pose_p_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__RaySceneQueryResultEntry_Ogre__STLAllocatorT_Ogre__RaySceneQueryResultEntry_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__RaySceneQueryResultEntry_Ogre__STLAllocatorT_Ogre__RaySceneQueryResultEntry_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__RenderQueueInvocation_p_Ogre__STLAllocatorT_Ogre__RenderQueueInvocation_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__RenderQueueInvocation_p_Ogre__STLAllocatorT_Ogre__RenderQueueInvocation_p_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__RenderSystem_p_Ogre__STLAllocatorT_Ogre__RenderSystem_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__RenderSystem_p_Ogre__STLAllocatorT_Ogre__RenderSystem_p_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__RenderWindowDescription_Ogre__STLAllocatorT_Ogre__RenderWindowDescription_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__RenderWindowDescription_Ogre__STLAllocatorT_Ogre__RenderWindowDescription_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__RenderWindow_p_Ogre__STLAllocatorT_Ogre__RenderWindow_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__RenderWindow_p_Ogre__STLAllocatorT_Ogre__RenderWindow_p_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__ScriptTokenPtr_Ogre__STLAllocatorT_Ogre__ScriptTokenPtr_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__ScriptTokenPtr_Ogre__STLAllocatorT_Ogre__ScriptTokenPtr_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__ShadowTextureConfig_Ogre__STLAllocatorT_Ogre__ShadowTextureConfig_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__ShadowTextureConfig_Ogre__STLAllocatorT_Ogre__ShadowTextureConfig_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__TerrainLayerBlendMap_p_Ogre__STLAllocatorT_Ogre__TerrainLayerBlendMap_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__TerrainLayerBlendMap_p_Ogre__STLAllocatorT_Ogre__TerrainLayerBlendMap_p_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__TerrainLayerSamplerElement_Ogre__STLAllocatorT_Ogre__TerrainLayerSamplerElement_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__TerrainLayerSamplerElement_Ogre__STLAllocatorT_Ogre__TerrainLayerSamplerElement_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__TerrainLayerSampler_Ogre__STLAllocatorT_Ogre__TerrainLayerSampler_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__TerrainLayerSampler_Ogre__STLAllocatorT_Ogre__TerrainLayerSampler_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__TexturePtr_Ogre__STLAllocatorT_Ogre__TexturePtr_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__TexturePtr_Ogre__STLAllocatorT_Ogre__TexturePtr_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_float_Ogre__STLAllocatorT_float_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_float_Ogre__STLAllocatorT_float_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_int_Ogre__STLAllocatorT_int_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_int_Ogre__STLAllocatorT_int_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OptimalAdjustFactorList[] = {  {&_swigt__p_OptimalAdjustFactorList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OptimisedSubMeshGeometryList[] = {  {&_swigt__p_OptimisedSubMeshGeometryList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Overlay2DElementsIterator[] = {  {&_swigt__p_Overlay2DElementsIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OverlayContainerList[] = {  {&_swigt__p_OverlayContainerList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OverlayMap[] = {  {&_swigt__p_OverlayMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_OverlayMapIterator[] = {  {&_swigt__p_OverlayMapIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PageMap[] = {  {&_swigt__p_PageMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ParticleAffectorFactoryIterator[] = {  {&_swigt__p_ParticleAffectorFactoryIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ParticleAffectorFactoryMap[] = {  {&_swigt__p_ParticleAffectorFactoryMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ParticleEmitterFactoryIterator[] = {  {&_swigt__p_ParticleEmitterFactoryIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ParticleEmitterFactoryMap[] = {  {&_swigt__p_ParticleEmitterFactoryMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ParticleRendererFactoryIterator[] = {  {&_swigt__p_ParticleRendererFactoryIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ParticleSystemRendererFactoryMap[] = {  {&_swigt__p_ParticleSystemRendererFactoryMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ParticleSystemTemplateIterator[] = {  {&_swigt__p_ParticleSystemTemplateIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ParticleTemplateMap[] = {  {&_swigt__p_ParticleTemplateMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PassIterator[] = {  {&_swigt__p_PassIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PassSet[] = {  {&_swigt__p_PassSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Passes[] = {  {&_swigt__p_Passes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PlaneList[] = {  {&_swigt__p_PlaneList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PluginInstanceList[] = {  {&_swigt__p_PluginInstanceList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PluginLibList[] = {  {&_swigt__p_PluginLibList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PolygonList[] = {  {&_swigt__p_PolygonList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PoseIterator[] = {  {&_swigt__p_PoseIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PoseRefIterator[] = {  {&_swigt__p_PoseRefIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PoseRefList[] = {  {&_swigt__p_PoseRefList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PriorityMap[] = {  {&_swigt__p_PriorityMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_PriorityMapIterator[] = {  {&_swigt__p_PriorityMapIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__BoxGenerator[] = {  {&_swigt__p_Procedural__BoxGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__CapsuleGenerator[] = {  {&_swigt__p_Procedural__CapsuleGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__CatmullRomSpline2[] = {  {&_swigt__p_Procedural__CatmullRomSpline2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__CatmullRomSpline3[] = {  {&_swigt__p_Procedural__CatmullRomSpline3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__Circle[] = {  {&_swigt__p_Procedural__Circle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__CircleShape[] = {  {&_swigt__p_Procedural__CircleShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__ConeGenerator[] = {  {&_swigt__p_Procedural__ConeGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__CubicHermiteSpline2[] = {  {&_swigt__p_Procedural__CubicHermiteSpline2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__CubicHermiteSpline3[] = {  {&_swigt__p_Procedural__CubicHermiteSpline3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__CylinderGenerator[] = {  {&_swigt__p_Procedural__CylinderGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__Extruder[] = {  {&_swigt__p_Procedural__Extruder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__IcoSphereGenerator[] = {  {&_swigt__p_Procedural__IcoSphereGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__KochanekBartelsSpline2[] = {  {&_swigt__p_Procedural__KochanekBartelsSpline2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__Lathe[] = {  {&_swigt__p_Procedural__Lathe, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__Line[] = {  {&_swigt__p_Procedural__Line, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__Line2D[] = {  {&_swigt__p_Procedural__Line2D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__LinePath[] = {  {&_swigt__p_Procedural__LinePath, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t[] = {  {&_swigt__p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0, 0, 0},  {&_swigt__p_Procedural__BoxGenerator, _p_Procedural__BoxGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t[] = {  {&_swigt__p_Procedural__CapsuleGenerator, _p_Procedural__CapsuleGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0, 0},  {&_swigt__p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t[] = {  {&_swigt__p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0, 0, 0},  {&_swigt__p_Procedural__ConeGenerator, _p_Procedural__ConeGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t[] = {  {&_swigt__p_Procedural__CylinderGenerator, _p_Procedural__CylinderGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0, 0},  {&_swigt__p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t[] = {  {&_swigt__p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0, 0, 0},  {&_swigt__p_Procedural__IcoSphereGenerator, _p_Procedural__IcoSphereGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t[] = {  {&_swigt__p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0, 0, 0},  {&_swigt__p_Procedural__PlaneGenerator, _p_Procedural__PlaneGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t[] = {  {&_swigt__p_Procedural__RoundedBoxGenerator, _p_Procedural__RoundedBoxGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0, 0},  {&_swigt__p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t[] = {  {&_swigt__p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0, 0, 0},  {&_swigt__p_Procedural__SphereGenerator, _p_Procedural__SphereGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t[] = {  {&_swigt__p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0, 0, 0},  {&_swigt__p_Procedural__TorusGenerator, _p_Procedural__TorusGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t[] = {  {&_swigt__p_Procedural__TorusKnotGenerator, _p_Procedural__TorusKnotGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0, 0},  {&_swigt__p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t[] = {  {&_swigt__p_Procedural__TubeGenerator, _p_Procedural__TubeGeneratorTo_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0, 0},  {&_swigt__p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__MultiShape[] = {  {&_swigt__p_Procedural__MultiShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__Path[] = {  {&_swigt__p_Procedural__Path, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__Plane[] = {  {&_swigt__p_Procedural__Plane, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__PlaneGenerator[] = {  {&_swigt__p_Procedural__PlaneGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__RectangleShape[] = {  {&_swigt__p_Procedural__RectangleShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__Root[] = {  {&_swigt__p_Procedural__Root, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__RoundedBoxGenerator[] = {  {&_swigt__p_Procedural__RoundedBoxGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__RoundedCornerSpline2[] = {  {&_swigt__p_Procedural__RoundedCornerSpline2, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__RoundedCornerSpline3[] = {  {&_swigt__p_Procedural__RoundedCornerSpline3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__Segment2D[] = {  {&_swigt__p_Procedural__Segment2D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__Shape[] = {  {&_swigt__p_Procedural__Shape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__SphereGenerator[] = {  {&_swigt__p_Procedural__SphereGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__TorusGenerator[] = {  {&_swigt__p_Procedural__TorusGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__TorusKnotGenerator[] = {  {&_swigt__p_Procedural__TorusKnotGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__Track[] = {  {&_swigt__p_Procedural__Track, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__TriangleBuffer[] = {  {&_swigt__p_Procedural__TriangleBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__Triangulator[] = {  {&_swigt__p_Procedural__Triangulator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__TubeGenerator[] = {  {&_swigt__p_Procedural__TubeGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Procedural__Utils[] = {  {&_swigt__p_Procedural__Utils, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ProfileList[] = {  {&_swigt__p_ProfileList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QuadMaterialMap[] = {  {&_swigt__p_QuadMaterialMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QueueGroupIterator[] = {  {&_swigt__p_QueueGroupIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QueuedGeometryList[] = {  {&_swigt__p_QueuedGeometryList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QueuedSubMeshList[] = {  {&_swigt__p_QueuedSubMeshList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_QueuedSubMeshOriginList[] = {  {&_swigt__p_QueuedSubMeshOriginList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RealVector[] = {  {&_swigt__p_RealVector, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Rect[] = {  {&_swigt__p_Rect, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RegionIterator[] = {  {&_swigt__p_RegionIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RegionMap[] = {  {&_swigt__p_RegionMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RenderOperationVector[] = {  {&_swigt__p_RenderOperationVector, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RenderSystemOpPair[] = {  {&_swigt__p_RenderSystemOpPair, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RenderSystemOpPairs[] = {  {&_swigt__p_RenderSystemOpPairs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RenderTargetIterator[] = {  {&_swigt__p_RenderTargetIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RequestID[] = {  {&_swigt__p_RequestID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ResourceCreateOrRetrieveResult[] = {  {&_swigt__p_ResourceCreateOrRetrieveResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ResourceDeclarationList[] = {  {&_swigt__p_ResourceDeclarationList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ResourceHandleMap[] = {  {&_swigt__p_ResourceHandleMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ResourceManagerIterator[] = {  {&_swigt__p_ResourceManagerIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ResourceManagerMap[] = {  {&_swigt__p_ResourceManagerMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ResourceMap[] = {  {&_swigt__p_ResourceMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ResourceMapIterator[] = {  {&_swigt__p_ResourceMapIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ResourceWithGroupMap[] = {  {&_swigt__p_ResourceWithGroupMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SceneManagerIterator[] = {  {&_swigt__p_SceneManagerIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SchemeHardwareAnimMap[] = {  {&_swigt__p_SchemeHardwareAnimMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SectionIterator[] = {  {&_swigt__p_SectionIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SectionList[] = {  {&_swigt__p_SectionList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SectionMap[] = {  {&_swigt__p_SectionMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SettingsBySection[] = {  {&_swigt__p_SettingsBySection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SettingsIterator[] = {  {&_swigt__p_SettingsIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SettingsMultiMap[] = {  {&_swigt__p_SettingsMultiMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShaderProfiles[] = {  {&_swigt__p_ShaderProfiles, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShadowRenderableList[] = {  {&_swigt__p_ShadowRenderableList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ShadowRenderableListIterator[] = {  {&_swigt__p_ShadowRenderableListIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SharedParametersMap[] = {  {&_swigt__p_SharedParametersMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SplitPointList[] = {  {&_swigt__p_SplitPointList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StrStreamType[] = {  {&_swigt__p_StrStreamType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_StrategyMap[] = {  {&_swigt__p_StrategyMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SubMeshGeometryLookup[] = {  {&_swigt__p_SubMeshGeometryLookup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SubMeshIterator[] = {  {&_swigt__p_SubMeshIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SubMeshList[] = {  {&_swigt__p_SubMeshList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SubMeshLodGeometryLinkList[] = {  {&_swigt__p_SubMeshLodGeometryLinkList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SubMeshNameMap[] = {  {&_swigt__p_SubMeshNameMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SyntaxCodes[] = {  {&_swigt__p_SyntaxCodes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TargetPassIterator[] = {  {&_swigt__p_TargetPassIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TargetPasses[] = {  {&_swigt__p_TargetPasses, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TechniqueIterator[] = {  {&_swigt__p_TechniqueIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Techniques[] = {  {&_swigt__p_Techniques, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TemplateIterator[] = {  {&_swigt__p_TemplateIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TerrainIterator[] = {  {&_swigt__p_TerrainIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TerrainList[] = {  {&_swigt__p_TerrainList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TerrainSlotMap[] = {  {&_swigt__p_TerrainSlotMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TextureDefinitionIterator[] = {  {&_swigt__p_TextureDefinitionIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TextureDefinitions[] = {  {&_swigt__p_TextureDefinitions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TextureUnitStateIterator[] = {  {&_swigt__p_TextureUnitStateIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TrackHandleList[] = {  {&_swigt__p_TrackHandleList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TriangleFaceNormalList[] = {  {&_swigt__p_TriangleFaceNormalList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TriangleLightFacingList[] = {  {&_swigt__p_TriangleLightFacingList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_TriangleList[] = {  {&_swigt__p_TriangleList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UVRect[] = {  {&_swigt__p_UVRect, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_UniqueTextureSet[] = {  {&_swigt__p_UniqueTextureSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VertexBoneAssignmentList[] = {  {&_swigt__p_VertexBoneAssignmentList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VertexBufferBindingMap[] = {  {&_swigt__p_VertexBufferBindingMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VertexElementList[] = {  {&_swigt__p_VertexElementList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VertexList[] = {  {&_swigt__p_VertexList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VertexOffsetIterator[] = {  {&_swigt__p_VertexOffsetIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VertexOffsetMap[] = {  {&_swigt__p_VertexOffsetMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VertexSplit[] = {  {&_swigt__p_VertexSplit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VertexSplits[] = {  {&_swigt__p_VertexSplits, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VertexTrackIterator[] = {  {&_swigt__p_VertexTrackIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_VertexTrackList[] = {  {&_swigt__p_VertexTrackList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_WindowEventListeners[] = {  {&_swigt__p_WindowEventListeners, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Windows[] = {  {&_swigt__p_Windows, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_WorldMap[] = {  {&_swigt__p_WorldMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_WorldSectionFactoryMap[] = {  {&_swigt__p_WorldSectionFactoryMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__zzip_plugin_io[] = {  {&_swigt__p__zzip_plugin_io, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_code_point[] = {  {&_swigt__p_code_point, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_const_iterator[] = {  {&_swigt__p_const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_const_reverse_iterator[] = {  {&_swigt__p_const_reverse_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_dstring[] = {  {&_swigt__p_dstring, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Intp[] = {{&_swigt__p_Intp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_Intp, _p_IntpTo_p_int, 0, 0},  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iterator[] = {  {&_swigt__p_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long_long[] = {  {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_reverse_iterator[] = {  {&_swigt__p_reverse_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {  {&_swigt__p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_Ogre__Real_Ogre__Real_std__lessT_Ogre__Real_t_std__allocatorT_std__pairT_Ogre__Real_const_Ogre__Real_t_t_t__const_iterator[] = {  {&_swigt__p_std__mapT_Ogre__Real_Ogre__Real_std__lessT_Ogre__Real_t_std__allocatorT_std__pairT_Ogre__Real_const_Ogre__Real_t_t_t__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_Ogre__MovableObject_p_Ogre__MovableObject_p_t[] = {  {&_swigt__p_std__pairT_Ogre__MovableObject_p_Ogre__MovableObject_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_Ogre__MovableObject_p_Ogre__WorldFragment_p_t[] = {  {&_swigt__p_std__pairT_Ogre__MovableObject_p_Ogre__WorldFragment_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__string[] = {  {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Ogre__Vector2_std__allocatorT_Ogre__Vector2_t_t[] = {  {&_swigt__p_std__vectorT_Ogre__Vector2_std__allocatorT_Ogre__Vector2_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Ogre__Vector3_std__allocatorT_Ogre__Vector3_t_t[] = {  {&_swigt__p_std__vectorT_Ogre__Vector3_std__allocatorT_Ogre__Vector3_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Vertex_std__allocatorT_Vertex_t_t[] = {  {&_swigt__p_std__vectorT_Vertex_std__allocatorT_Vertex_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t[] = {  {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_stdext__hash_compareT_Ogre___StringBase_std__lessT_Ogre___StringBase_t_t[] = {  {&_swigt__p_stdext__hash_compareT_Ogre___StringBase_std__lessT_Ogre___StringBase_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unicode_char[] = {  {&_swigt__p_unicode_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long_long[] = {  {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_utf32string[] = {  {&_swigt__p_utf32string, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_z_stream_s[] = {  {&_swigt__p_z_stream_s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_zzip_dir[] = {  {&_swigt__p_zzip_dir, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_zzip_file[] = {  {&_swigt__p_zzip_file, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_AliasTextureIterator,
  _swigc__p_AnimationIterator,
  _swigc__p_ArchiveMapIterator,
  _swigc__p_AutoConstantIterator,
  _swigc__p_AutoConstantList,
  _swigc__p_BatchInstanceIterator,
  _swigc__p_BatchInstanceMap,
  _swigc__p_BindingIndexMap,
  _swigc__p_BoneAssignmentIterator,
  _swigc__p_BoneBlendMask,
  _swigc__p_BoneHandleMap,
  _swigc__p_BoneIterator,
  _swigc__p_BoneList,
  _swigc__p_BoundSufaceList,
  _swigc__p_Box,
  _swigc__p_CameraIterator,
  _swigc__p_CameraList,
  _swigc__p_ChildContainerIterator,
  _swigc__p_ChildContainerMap,
  _swigc__p_ChildIterator,
  _swigc__p_ChildMap,
  _swigc__p_ChildNodeIterator,
  _swigc__p_ChildNodeMap,
  _swigc__p_ChildObjectList,
  _swigc__p_ChildObjectListIterator,
  _swigc__p_CodePoint,
  _swigc__p_CodePointRange,
  _swigc__p_CodePointRangeList,
  _swigc__p_CodecDataPtr,
  _swigc__p_CodecIterator,
  _swigc__p_CompiledState,
  _swigc__p_ConstChildNodeIterator,
  _swigc__p_ConstNormalsIterator,
  _swigc__p_ConstObjectIterator,
  _swigc__p_ConstPoseIterator,
  _swigc__p_ConstPoseRefIterator,
  _swigc__p_ConstPriorityMapIterator,
  _swigc__p_ConstQueueGroupIterator,
  _swigc__p_ConstTerrainIterator,
  _swigc__p_ConstTextureUnitStateIterator,
  _swigc__p_ConstVertexOffsetIterator,
  _swigc__p_ContentCollectionFactoryMap,
  _swigc__p_ContentCollectionList,
  _swigc__p_ContentFactoryMap,
  _swigc__p_ContentList,
  _swigc__p_CornerEnum,
  _swigc__p_DecodeResult,
  _swigc__p_Edge,
  _swigc__p_EdgeGroupList,
  _swigc__p_EdgeList,
  _swigc__p_EdgeMap,
  _swigc__p_EffectMap,
  _swigc__p_ElementList,
  _swigc__p_ElementMap,
  _swigc__p_EntitySet,
  _swigc__p_ErrorList,
  _swigc__p_ErrorPtr,
  _swigc__p_FactoryMap,
  _swigc__p_GPUDeviceNameRuleIterator,
  _swigc__p_GPUDeviceNameRuleList,
  _swigc__p_GPUVendorRuleIterator,
  _swigc__p_GPUVendorRuleList,
  _swigc__p_GpuSharedParamUsageList,
  _swigc__p_HardwareAnimationDataList,
  _swigc__p_IdMap,
  _swigc__p_IlluminationPassIterator,
  _swigc__p_IndexMap,
  _swigc__p_IndexRemapList,
  _swigc__p_InstanceBatchIterator,
  _swigc__p_InstanceBatchMapIterator,
  _swigc__p_InstanceIterator,
  _swigc__p_InstancedEntityVec,
  _swigc__p_Instances,
  _swigc__p_Intp,
  _swigc__p_LODFaceList,
  _swigc__p_LayerInstanceList,
  _swigc__p_LinkedSkeletonAnimSourceIterator,
  _swigc__p_LinkedSkeletonAnimSourceList,
  _swigc__p_LocationList,
  _swigc__p_LodLevelList,
  _swigc__p_LodValueIterator,
  _swigc__p_LodValueList,
  _swigc__p_MeshLodUsageList,
  _swigc__p_MetaDataIterator,
  _swigc__p_MetaDataList,
  _swigc__p_Microcode,
  _swigc__p_MicrocodeMap,
  _swigc__p_MovableObjectFactoryIterator,
  _swigc__p_MovableObjectIterator,
  _swigc__p_NodeIterator,
  _swigc__p_NodeList,
  _swigc__p_NodeTrackIterator,
  _swigc__p_NodeTrackList,
  _swigc__p_NormalsIterator,
  _swigc__p_NormalsMap,
  _swigc__p_NumericTrackIterator,
  _swigc__p_NumericTrackList,
  _swigc__p_ObjectIterator,
  _swigc__p_ObjectMap,
  _swigc__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_ANIMATION_t_t,
  _swigc__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GENERAL_t_t,
  _swigc__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_t_t,
  _swigc__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RENDERSYS_t_t,
  _swigc__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RESOURCE_t_t,
  _swigc__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_CONTROL_t_t,
  _swigc__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_OBJECTS_t_t,
  _swigc__p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCRIPTING_t_t,
  _swigc__p_Ogre__AnimationStateIterator,
  _swigc__p_Ogre__AxisAlignedBox,
  _swigc__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_ANIMATION_t,
  _swigc__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GENERAL_t,
  _swigc__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_t,
  _swigc__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RENDERSYS_t,
  _swigc__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RESOURCE_t,
  _swigc__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_CONTROL_t,
  _swigc__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_OBJECTS_t,
  _swigc__p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCRIPTING_t,
  _swigc__p_Ogre__ConstAnimationStateIterator,
  _swigc__p_Ogre__ConstEnabledAnimationStateIterator,
  _swigc__p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__GpuConstantDefinition_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuConstantDefinition_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__ConstShadowTextureConfigIterator,
  _swigc__p_Ogre__HashedVectorT_Ogre__Light_p_t,
  _swigc__p_Ogre__ManualObject,
  _swigc__p_Ogre__Matrix4,
  _swigc__p_Ogre__MeshPtr,
  _swigc__p_Ogre__MovablePlane,
  _swigc__p_Ogre__Plane,
  _swigc__p_Ogre__Quaternion,
  _swigc__p_Ogre__Radian,
  _swigc__p_Ogre__Rectangle,
  _swigc__p_Ogre__SharedPtrT_Ogre__AbstractNode_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__AnimableValue_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__ConcreteNode_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__ControllerFunctionT_float_t_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__ControllerValueT_float_t_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__DataStream_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__GpuLogicalBufferStruct_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__GpuNamedConstants_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__GpuSharedParameters_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__MemoryDataStream_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__RenderToVertexBuffer_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__Resource_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__ScriptToken_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__ShadowCameraSetup_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__TerrainMaterialGenerator_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__listT_Ogre__DataStreamPtr_Ogre__STLAllocatorT_Ogre__DataStreamPtr_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__ScriptTokenPtr_Ogre__STLAllocatorT_Ogre__ScriptTokenPtr_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__SimpleSpline,
  _swigc__p_Ogre__TRectT_float_t,
  _swigc__p_Ogre__TRectT_long_t,
  _swigc__p_Ogre__UTFString,
  _swigc__p_Ogre__Vector2,
  _swigc__p_Ogre__Vector3,
  _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__RenderQueueInvocation_p_Ogre__STLAllocatorT_Ogre__RenderQueueInvocation_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__VertexBoneAssignment_s,
  _swigc__p_Ogre___ConfigOption,
  _swigc__p_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__listT_Ogre__AnimationState_p_Ogre__STLAllocatorT_Ogre__AnimationState_p_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__listT_Ogre__DataStreamPtr_Ogre__STLAllocatorT_Ogre__DataStreamPtr_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__listT_Ogre__MovableObject_p_Ogre__STLAllocatorT_Ogre__MovableObject_p_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__listT_Ogre__SceneQueryMovableObjectPair_Ogre__STLAllocatorT_Ogre__SceneQueryMovableObjectPair_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__listT_Ogre__SceneQueryMovableObjectWorldFragmentPair_Ogre__STLAllocatorT_Ogre__SceneQueryMovableObjectWorldFragmentPair_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__listT_Ogre__WorldFragment_p_Ogre__STLAllocatorT_Ogre__WorldFragment_p_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_Ogre__String_Ogre__AnimationState_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__AnimationState_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_Ogre__String_Ogre__ConfigOption_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ConfigOption_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_Ogre__String_Ogre__GpuConstantDefinition_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuConstantDefinition_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_Ogre__String_Ogre__ParamCommand_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParamCommand_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_Ogre__String_Ogre__ParamDictionary_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParamDictionary_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_Ogre__String_Ogre__RenderTarget_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__RenderTarget_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_Ogre__String_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_Ogre__String_bool_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_bool_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_Ogre__uint16_Ogre__DepthBufferVec_std__lessT_Ogre__uint16_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint16_const_Ogre__DepthBufferVec_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_size_t_Ogre__GpuLogicalIndexUse_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__GpuLogicalIndexUse_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__multimapT_Ogre__uchar_Ogre__RenderTarget_p_std__lessT_Ogre__uchar_t_Ogre__STLAllocatorT_std__pairT_Ogre__uchar_const_Ogre__RenderTarget_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__DepthBuffer_p_Ogre__STLAllocatorT_Ogre__DepthBuffer_p_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__HardwareBuffer__Usage_Ogre__STLAllocatorT_Ogre__HardwareBuffer__Usage_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__IlluminationPass_p_Ogre__STLAllocatorT_Ogre__IlluminationPass_p_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__Image_const_p_Ogre__STLAllocatorT_Ogre__Image_const_p_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__Image_p_Ogre__STLAllocatorT_Ogre__Image_p_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__ParameterDef_Ogre__STLAllocatorT_Ogre__ParameterDef_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__PixelFormat_Ogre__STLAllocatorT_Ogre__PixelFormat_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__PlaneBoundedVolume_Ogre__STLAllocatorT_Ogre__PlaneBoundedVolume_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__Pose_p_Ogre__STLAllocatorT_Ogre__Pose_p_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__RaySceneQueryResultEntry_Ogre__STLAllocatorT_Ogre__RaySceneQueryResultEntry_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__RenderQueueInvocation_p_Ogre__STLAllocatorT_Ogre__RenderQueueInvocation_p_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__RenderSystem_p_Ogre__STLAllocatorT_Ogre__RenderSystem_p_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__RenderWindowDescription_Ogre__STLAllocatorT_Ogre__RenderWindowDescription_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__RenderWindow_p_Ogre__STLAllocatorT_Ogre__RenderWindow_p_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__ScriptTokenPtr_Ogre__STLAllocatorT_Ogre__ScriptTokenPtr_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__ShadowTextureConfig_Ogre__STLAllocatorT_Ogre__ShadowTextureConfig_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__TerrainLayerBlendMap_p_Ogre__STLAllocatorT_Ogre__TerrainLayerBlendMap_p_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__TerrainLayerSamplerElement_Ogre__STLAllocatorT_Ogre__TerrainLayerSamplerElement_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__TerrainLayerSampler_Ogre__STLAllocatorT_Ogre__TerrainLayerSampler_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__TexturePtr_Ogre__STLAllocatorT_Ogre__TexturePtr_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_float_Ogre__STLAllocatorT_float_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_int_Ogre__STLAllocatorT_int_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_OptimalAdjustFactorList,
  _swigc__p_OptimisedSubMeshGeometryList,
  _swigc__p_Overlay2DElementsIterator,
  _swigc__p_OverlayContainerList,
  _swigc__p_OverlayMap,
  _swigc__p_OverlayMapIterator,
  _swigc__p_PageMap,
  _swigc__p_ParticleAffectorFactoryIterator,
  _swigc__p_ParticleAffectorFactoryMap,
  _swigc__p_ParticleEmitterFactoryIterator,
  _swigc__p_ParticleEmitterFactoryMap,
  _swigc__p_ParticleRendererFactoryIterator,
  _swigc__p_ParticleSystemRendererFactoryMap,
  _swigc__p_ParticleSystemTemplateIterator,
  _swigc__p_ParticleTemplateMap,
  _swigc__p_PassIterator,
  _swigc__p_PassSet,
  _swigc__p_Passes,
  _swigc__p_PlaneList,
  _swigc__p_PluginInstanceList,
  _swigc__p_PluginLibList,
  _swigc__p_PolygonList,
  _swigc__p_PoseIterator,
  _swigc__p_PoseRefIterator,
  _swigc__p_PoseRefList,
  _swigc__p_PriorityMap,
  _swigc__p_PriorityMapIterator,
  _swigc__p_Procedural__BoxGenerator,
  _swigc__p_Procedural__CapsuleGenerator,
  _swigc__p_Procedural__CatmullRomSpline2,
  _swigc__p_Procedural__CatmullRomSpline3,
  _swigc__p_Procedural__Circle,
  _swigc__p_Procedural__CircleShape,
  _swigc__p_Procedural__ConeGenerator,
  _swigc__p_Procedural__CubicHermiteSpline2,
  _swigc__p_Procedural__CubicHermiteSpline3,
  _swigc__p_Procedural__CylinderGenerator,
  _swigc__p_Procedural__Extruder,
  _swigc__p_Procedural__IcoSphereGenerator,
  _swigc__p_Procedural__KochanekBartelsSpline2,
  _swigc__p_Procedural__Lathe,
  _swigc__p_Procedural__Line,
  _swigc__p_Procedural__Line2D,
  _swigc__p_Procedural__LinePath,
  _swigc__p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t,
  _swigc__p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t,
  _swigc__p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t,
  _swigc__p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t,
  _swigc__p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t,
  _swigc__p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t,
  _swigc__p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t,
  _swigc__p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t,
  _swigc__p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t,
  _swigc__p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t,
  _swigc__p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t,
  _swigc__p_Procedural__MultiShape,
  _swigc__p_Procedural__Path,
  _swigc__p_Procedural__Plane,
  _swigc__p_Procedural__PlaneGenerator,
  _swigc__p_Procedural__RectangleShape,
  _swigc__p_Procedural__Root,
  _swigc__p_Procedural__RoundedBoxGenerator,
  _swigc__p_Procedural__RoundedCornerSpline2,
  _swigc__p_Procedural__RoundedCornerSpline3,
  _swigc__p_Procedural__Segment2D,
  _swigc__p_Procedural__Shape,
  _swigc__p_Procedural__SphereGenerator,
  _swigc__p_Procedural__TorusGenerator,
  _swigc__p_Procedural__TorusKnotGenerator,
  _swigc__p_Procedural__Track,
  _swigc__p_Procedural__TriangleBuffer,
  _swigc__p_Procedural__Triangulator,
  _swigc__p_Procedural__TubeGenerator,
  _swigc__p_Procedural__Utils,
  _swigc__p_ProfileList,
  _swigc__p_QuadMaterialMap,
  _swigc__p_QueueGroupIterator,
  _swigc__p_QueuedGeometryList,
  _swigc__p_QueuedSubMeshList,
  _swigc__p_QueuedSubMeshOriginList,
  _swigc__p_RealVector,
  _swigc__p_Rect,
  _swigc__p_RegionIterator,
  _swigc__p_RegionMap,
  _swigc__p_RenderOperationVector,
  _swigc__p_RenderSystemOpPair,
  _swigc__p_RenderSystemOpPairs,
  _swigc__p_RenderTargetIterator,
  _swigc__p_RequestID,
  _swigc__p_ResourceCreateOrRetrieveResult,
  _swigc__p_ResourceDeclarationList,
  _swigc__p_ResourceHandleMap,
  _swigc__p_ResourceManagerIterator,
  _swigc__p_ResourceManagerMap,
  _swigc__p_ResourceMap,
  _swigc__p_ResourceMapIterator,
  _swigc__p_ResourceWithGroupMap,
  _swigc__p_SceneManagerIterator,
  _swigc__p_SchemeHardwareAnimMap,
  _swigc__p_SectionIterator,
  _swigc__p_SectionList,
  _swigc__p_SectionMap,
  _swigc__p_SettingsBySection,
  _swigc__p_SettingsIterator,
  _swigc__p_SettingsMultiMap,
  _swigc__p_ShaderProfiles,
  _swigc__p_ShadowRenderableList,
  _swigc__p_ShadowRenderableListIterator,
  _swigc__p_SharedParametersMap,
  _swigc__p_SplitPointList,
  _swigc__p_StrStreamType,
  _swigc__p_StrategyMap,
  _swigc__p_SubMeshGeometryLookup,
  _swigc__p_SubMeshIterator,
  _swigc__p_SubMeshList,
  _swigc__p_SubMeshLodGeometryLinkList,
  _swigc__p_SubMeshNameMap,
  _swigc__p_SyntaxCodes,
  _swigc__p_TargetPassIterator,
  _swigc__p_TargetPasses,
  _swigc__p_TechniqueIterator,
  _swigc__p_Techniques,
  _swigc__p_TemplateIterator,
  _swigc__p_TerrainIterator,
  _swigc__p_TerrainList,
  _swigc__p_TerrainSlotMap,
  _swigc__p_TextureDefinitionIterator,
  _swigc__p_TextureDefinitions,
  _swigc__p_TextureUnitStateIterator,
  _swigc__p_TrackHandleList,
  _swigc__p_TriangleFaceNormalList,
  _swigc__p_TriangleLightFacingList,
  _swigc__p_TriangleList,
  _swigc__p_UVRect,
  _swigc__p_UniqueTextureSet,
  _swigc__p_VertexBoneAssignmentList,
  _swigc__p_VertexBufferBindingMap,
  _swigc__p_VertexElementList,
  _swigc__p_VertexList,
  _swigc__p_VertexOffsetIterator,
  _swigc__p_VertexOffsetMap,
  _swigc__p_VertexSplit,
  _swigc__p_VertexSplits,
  _swigc__p_VertexTrackIterator,
  _swigc__p_VertexTrackList,
  _swigc__p_WindowEventListeners,
  _swigc__p_Windows,
  _swigc__p_WorldMap,
  _swigc__p_WorldSectionFactoryMap,
  _swigc__p__zzip_plugin_io,
  _swigc__p_char,
  _swigc__p_code_point,
  _swigc__p_const_iterator,
  _swigc__p_const_reverse_iterator,
  _swigc__p_dstring,
  _swigc__p_float,
  _swigc__p_int,
  _swigc__p_iterator,
  _swigc__p_long_long,
  _swigc__p_reverse_iterator,
  _swigc__p_short,
  _swigc__p_size_type,
  _swigc__p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_std__mapT_Ogre__Real_Ogre__Real_std__lessT_Ogre__Real_t_std__allocatorT_std__pairT_Ogre__Real_const_Ogre__Real_t_t_t__const_iterator,
  _swigc__p_std__pairT_Ogre__MovableObject_p_Ogre__MovableObject_p_t,
  _swigc__p_std__pairT_Ogre__MovableObject_p_Ogre__WorldFragment_p_t,
  _swigc__p_std__string,
  _swigc__p_std__vectorT_Ogre__Vector2_std__allocatorT_Ogre__Vector2_t_t,
  _swigc__p_std__vectorT_Ogre__Vector3_std__allocatorT_Ogre__Vector3_t_t,
  _swigc__p_std__vectorT_Vertex_std__allocatorT_Vertex_t_t,
  _swigc__p_std__vectorT_int_std__allocatorT_int_t_t,
  _swigc__p_stdext__hash_compareT_Ogre___StringBase_std__lessT_Ogre___StringBase_t_t,
  _swigc__p_unicode_char,
  _swigc__p_unsigned_char,
  _swigc__p_unsigned_int,
  _swigc__p_unsigned_long,
  _swigc__p_unsigned_long_long,
  _swigc__p_unsigned_short,
  _swigc__p_utf32string,
  _swigc__p_value_type,
  _swigc__p_z_stream_s,
  _swigc__p_zzip_dir,
  _swigc__p_zzip_file,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is tough by the requirement that no dynamic 
 * memory is used. Also, since swig_type_info structures store pointers to 
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization. 
 * The idea is that swig generates all the structures that are needed. 
 * The runtime then collects these partially filled structures. 
 * The SWIG_InitializeModule function takes these initial arrays out of 
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned staticly to an initial 
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast linked list. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it 
 * adding the casts to the list. The one last trick we need to do is making
 * sure the type pointer in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded. 
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the 
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif


SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int found, init;

  clientdata = clientdata;

  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }

  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
    module_head = &swig_module;
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    found=0;
    iter=module_head;
    do {
      if (iter==&swig_module) {
        found=1;
        break;
      }
      iter=iter->next;
    } while (iter!= module_head);

    /* if the is found in the list, then all is done and we may leave */
    if (found) return;
    /* otherwise we must add out module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }

  /* When multiple interpeters are used, a module could have already been initialized in
     a different interpreter, but not yet have a pointer in this interpreter.
     In this case, we do not want to continue adding types... everything should be
     set up already */
  if (init == 0) return;

  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *ret;
    swig_cast_info *cast;
  
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
#endif

    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
	type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }

    /* Insert casting types */
    cast = swig_module.cast_initial[i];
    while (cast->type) {
    
      /* Don't need to add information already in the list */
      ret = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
      }
      if (ret) {
	if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
	  cast->type = ret;
	  ret = 0;
	} else {
	  /* Check for casting already in the list */
	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
	  if (!ocast) ret = 0;
	}
      }

      if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        if (type->cast) {
          type->cast->prev = cast;
          cast->next = type->cast;
        }
        type->cast = cast;
      }
      cast++;
    }
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;

#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
  printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* 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_PropagateClientData(void) {
  size_t i;
  swig_cast_info *equiv;
  static int init_run = 0;

  if (init_run) return;
  init_run = 1;

  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      equiv = swig_module.types[i]->cast;
      while (equiv) {
        if (!equiv->converter) {
          if (equiv->type && !equiv->type->clientdata)
            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
        }
        equiv = equiv->next;
      }
    }
  }
}

#ifdef __cplusplus
#if 0
{ /* c-mode */
#endif
}
#endif

/*

*/
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT void Init_procedural(void) {
  size_t i;
  
  SWIG_InitRuntime();
  mProcedural = rb_define_module("Procedural");
  
  SWIG_InitializeModule(0);
  for (i = 0; i < swig_module.size; i++) {
    SWIG_define_class(swig_module.types[i]);
  }
  
  SWIG_RubyInitializeTrackings();
  rb_define_const(mProcedural, "PROCEDURAL_PLATFORM_WIN32", SWIG_From_int(static_cast< int >(1)));
  rb_define_const(mProcedural, "PROCEDURAL_PLATFORM_LINUX", SWIG_From_int(static_cast< int >(2)));
  rb_define_const(mProcedural, "PROCEDURAL_PLATFORM_APPLE", SWIG_From_int(static_cast< int >(3)));
  rb_define_const(mProcedural, "PROCEDURAL_PLATFORM_SYMBIAN", SWIG_From_int(static_cast< int >(4)));
  rb_define_const(mProcedural, "PROCEDURAL_PLATFORM_APPLE_IOS", SWIG_From_int(static_cast< int >(5)));
  rb_define_const(mProcedural, "PROCEDURAL_PLATFORM_ANDROID", SWIG_From_int(static_cast< int >(6)));
  rb_define_const(mProcedural, "PROCEDURAL_PLATFORM_TEGRA2", SWIG_From_int(static_cast< int >(7)));
  rb_define_const(mProcedural, "PROCEDURAL_PLATFORM_NACL", SWIG_From_int(static_cast< int >(8)));
  rb_define_const(mProcedural, "PROCEDURAL_PLATFORM", SWIG_From_int(static_cast< int >(2)));
  rb_define_const(mProcedural, "PROCEDURAL_DEBUG_MODE", SWIG_From_int(static_cast< int >(1)));
  
  SwigClassRoot.klass = rb_define_class_under(mProcedural, "Root", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__Root, (void *) &SwigClassRoot);
  rb_undef_alloc_func(SwigClassRoot.klass);
  rb_define_singleton_method(SwigClassRoot.klass, "get_instance", VALUEFUNC(_wrap_Root_get_instance), -1);
  SwigClassRoot.mark = 0;
  SwigClassRoot.destroy = (void (*)(void *)) debug_free_ProcRoot;
  SwigClassRoot.trackObjects = 0;
  
  SwigClassUtils.klass = rb_define_class_under(mProcedural, "Utils", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__Utils, (void *) &SwigClassUtils);
  rb_define_alloc_func(SwigClassUtils.klass, _wrap_Utils_allocate);
  rb_define_method(SwigClassUtils.klass, "initialize", VALUEFUNC(_wrap_new_Utils), -1);
  rb_define_singleton_method(SwigClassUtils.klass, "log", VALUEFUNC(_wrap_Utils_log), -1);
  rb_define_singleton_method(SwigClassUtils.klass, "min", VALUEFUNC(_wrap_Utils_min), -1);
  rb_define_singleton_method(SwigClassUtils.klass, "max", VALUEFUNC(_wrap_Utils_max), -1);
  rb_define_singleton_method(SwigClassUtils.klass, "aabbfrom_points", VALUEFUNC(_wrap_Utils_aabbfrom_points), -1);
  rb_define_singleton_method(SwigClassUtils.klass, "get_name", VALUEFUNC(_wrap_Utils_get_name), -1);
  rb_define_singleton_method(SwigClassUtils.klass, "vector_permute", VALUEFUNC(_wrap_Utils_vector_permute), -1);
  rb_define_singleton_method(SwigClassUtils.klass, "vector_anti_permute", VALUEFUNC(_wrap_Utils_vector_anti_permute), -1);
  rb_define_singleton_method(SwigClassUtils.klass, "rotate_vector2", VALUEFUNC(_wrap_Utils_rotate_vector2), -1);
  rb_define_singleton_method(SwigClassUtils.klass, "cap", VALUEFUNC(_wrap_Utils_cap), -1);
  rb_define_singleton_method(SwigClassUtils.klass, "modulo", VALUEFUNC(_wrap_Utils_modulo), -1);
  rb_define_singleton_method(SwigClassUtils.klass, "angle_between", VALUEFUNC(_wrap_Utils_angle_between), -1);
  rb_define_singleton_method(SwigClassUtils.klass, "angle_to", VALUEFUNC(_wrap_Utils_angle_to), -1);
  rb_define_singleton_method(SwigClassUtils.klass, "_compute_quaternion", VALUEFUNC(_wrap_Utils__compute_quaternion), -1);
  rb_define_singleton_method(SwigClassUtils.klass, "vec_2to_vec_3y", VALUEFUNC(_wrap_Utils_vec_2to_vec_3y), -1);
  SwigClassUtils.mark = 0;
  SwigClassUtils.destroy = (void (*)(void *)) free_Procedural_Utils;
  SwigClassUtils.trackObjects = 0;
  
  SwigClassTriangleBuffer.klass = rb_define_class_under(mProcedural, "TriangleBuffer", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__TriangleBuffer, (void *) &SwigClassTriangleBuffer);
  rb_define_alloc_func(SwigClassTriangleBuffer.klass, _wrap_TriangleBuffer_allocate);
  rb_define_method(SwigClassTriangleBuffer.klass, "initialize", VALUEFUNC(_wrap_new_TriangleBuffer), -1);
  rb_define_method(SwigClassTriangleBuffer.klass, "get_vertices", VALUEFUNC(_wrap_TriangleBuffer_get_vertices), -1);
  rb_define_method(SwigClassTriangleBuffer.klass, "get_indices", VALUEFUNC(_wrap_TriangleBuffer_get_indices), -1);
  rb_define_method(SwigClassTriangleBuffer.klass, "rebase_offset", VALUEFUNC(_wrap_TriangleBuffer_rebase_offset), -1);
  rb_define_method(SwigClassTriangleBuffer.klass, "transform_to_mesh", VALUEFUNC(_wrap_TriangleBuffer_transform_to_mesh), -1);
  rb_define_method(SwigClassTriangleBuffer.klass, "position", VALUEFUNC(_wrap_TriangleBuffer_position), -1);
  rb_define_method(SwigClassTriangleBuffer.klass, "normal", VALUEFUNC(_wrap_TriangleBuffer_normal), -1);
  rb_define_method(SwigClassTriangleBuffer.klass, "texture_coord", VALUEFUNC(_wrap_TriangleBuffer_texture_coord), -1);
  rb_define_method(SwigClassTriangleBuffer.klass, "index", VALUEFUNC(_wrap_TriangleBuffer_index), -1);
  rb_define_method(SwigClassTriangleBuffer.klass, "triangle", VALUEFUNC(_wrap_TriangleBuffer_triangle), -1);
  rb_define_method(SwigClassTriangleBuffer.klass, "apply_transform", VALUEFUNC(_wrap_TriangleBuffer_apply_transform), -1);
  rb_define_method(SwigClassTriangleBuffer.klass, "translate", VALUEFUNC(_wrap_TriangleBuffer_translate), -1);
  rb_define_method(SwigClassTriangleBuffer.klass, "rotate", VALUEFUNC(_wrap_TriangleBuffer_rotate), -1);
  rb_define_method(SwigClassTriangleBuffer.klass, "scale", VALUEFUNC(_wrap_TriangleBuffer_scale), -1);
  rb_define_method(SwigClassTriangleBuffer.klass, "invert_normals", VALUEFUNC(_wrap_TriangleBuffer_invert_normals), -1);
  rb_define_method(SwigClassTriangleBuffer.klass, "estimate_vertex_count", VALUEFUNC(_wrap_TriangleBuffer_estimate_vertex_count), -1);
  rb_define_method(SwigClassTriangleBuffer.klass, "estimate_index_count", VALUEFUNC(_wrap_TriangleBuffer_estimate_index_count), -1);
  rb_define_method(SwigClassTriangleBuffer.klass, "_dump_contents_to_file", VALUEFUNC(_wrap_TriangleBuffer__dump_contents_to_file), -1);
  SwigClassTriangleBuffer.mark = 0;
  SwigClassTriangleBuffer.destroy = (void (*)(void *)) free_Procedural_TriangleBuffer;
  SwigClassTriangleBuffer.trackObjects = 0;
  
  SwigClassBoxMeshGenerator.klass = rb_define_class_under(mProcedural, "BoxMeshGenerator", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t, (void *) &SwigClassBoxMeshGenerator);
  rb_undef_alloc_func(SwigClassBoxMeshGenerator.klass);
  rb_define_method(SwigClassBoxMeshGenerator.klass, "realize_mesh", VALUEFUNC(_wrap_BoxMeshGenerator_realize_mesh), -1);
  rb_define_method(SwigClassBoxMeshGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_BoxMeshGenerator_add_to_triangle_buffer), -1);
  rb_define_method(SwigClassBoxMeshGenerator.klass, "set_utile", VALUEFUNC(_wrap_BoxMeshGenerator_set_utile), -1);
  rb_define_method(SwigClassBoxMeshGenerator.klass, "set_vtile", VALUEFUNC(_wrap_BoxMeshGenerator_set_vtile), -1);
  rb_define_method(SwigClassBoxMeshGenerator.klass, "set_texture_rectangle", VALUEFUNC(_wrap_BoxMeshGenerator_set_texture_rectangle), -1);
  rb_define_method(SwigClassBoxMeshGenerator.klass, "set_enable_normals", VALUEFUNC(_wrap_BoxMeshGenerator_set_enable_normals), -1);
  rb_define_method(SwigClassBoxMeshGenerator.klass, "set_num_tex_coord_set", VALUEFUNC(_wrap_BoxMeshGenerator_set_num_tex_coord_set), -1);
  rb_define_method(SwigClassBoxMeshGenerator.klass, "set_switch_uv", VALUEFUNC(_wrap_BoxMeshGenerator_set_switch_uv), -1);
  rb_define_method(SwigClassBoxMeshGenerator.klass, "set_orientation", VALUEFUNC(_wrap_BoxMeshGenerator_set_orientation), -1);
  rb_define_method(SwigClassBoxMeshGenerator.klass, "set_position", VALUEFUNC(_wrap_BoxMeshGenerator_set_position), -1);
  rb_define_method(SwigClassBoxMeshGenerator.klass, "set_scale", VALUEFUNC(_wrap_BoxMeshGenerator_set_scale), -1);
  rb_define_method(SwigClassBoxMeshGenerator.klass, "reset_transforms", VALUEFUNC(_wrap_BoxMeshGenerator_reset_transforms), -1);
  rb_define_method(SwigClassBoxMeshGenerator.klass, "_set_dump_to_file", VALUEFUNC(_wrap_BoxMeshGenerator__set_dump_to_file), -1);
  rb_define_method(SwigClassBoxMeshGenerator.klass, "_disable_dump_to_file", VALUEFUNC(_wrap_BoxMeshGenerator__disable_dump_to_file), -1);
  SwigClassBoxMeshGenerator.mark = 0;
  SwigClassBoxMeshGenerator.destroy = (void (*)(void *)) free_Procedural_MeshGenerator_Sl_Procedural_BoxGenerator_Sg_;
  SwigClassBoxMeshGenerator.trackObjects = 0;
  
  SwigClassBoxGenerator.klass = rb_define_class_under(mProcedural, "BoxGenerator", ((swig_class *) SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__BoxGenerator_t->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__BoxGenerator, (void *) &SwigClassBoxGenerator);
  rb_define_alloc_func(SwigClassBoxGenerator.klass, _wrap_BoxGenerator_allocate);
  rb_define_method(SwigClassBoxGenerator.klass, "initialize", VALUEFUNC(_wrap_new_BoxGenerator), -1);
  rb_define_method(SwigClassBoxGenerator.klass, "set_size_x", VALUEFUNC(_wrap_BoxGenerator_set_size_x), -1);
  rb_define_method(SwigClassBoxGenerator.klass, "set_size_y", VALUEFUNC(_wrap_BoxGenerator_set_size_y), -1);
  rb_define_method(SwigClassBoxGenerator.klass, "set_size_z", VALUEFUNC(_wrap_BoxGenerator_set_size_z), -1);
  rb_define_method(SwigClassBoxGenerator.klass, "set_size", VALUEFUNC(_wrap_BoxGenerator_set_size), -1);
  rb_define_method(SwigClassBoxGenerator.klass, "set_num_seg_x", VALUEFUNC(_wrap_BoxGenerator_set_num_seg_x), -1);
  rb_define_method(SwigClassBoxGenerator.klass, "set_num_seg_y", VALUEFUNC(_wrap_BoxGenerator_set_num_seg_y), -1);
  rb_define_method(SwigClassBoxGenerator.klass, "set_num_seg_z", VALUEFUNC(_wrap_BoxGenerator_set_num_seg_z), -1);
  rb_define_method(SwigClassBoxGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_BoxGenerator_add_to_triangle_buffer), -1);
  SwigClassBoxGenerator.mark = 0;
  SwigClassBoxGenerator.destroy = (void (*)(void *)) free_Procedural_BoxGenerator;
  SwigClassBoxGenerator.trackObjects = 0;
  
  SwigClassCapsuleMeshGenerator.klass = rb_define_class_under(mProcedural, "CapsuleMeshGenerator", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t, (void *) &SwigClassCapsuleMeshGenerator);
  rb_undef_alloc_func(SwigClassCapsuleMeshGenerator.klass);
  rb_define_method(SwigClassCapsuleMeshGenerator.klass, "realize_mesh", VALUEFUNC(_wrap_CapsuleMeshGenerator_realize_mesh), -1);
  rb_define_method(SwigClassCapsuleMeshGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_CapsuleMeshGenerator_add_to_triangle_buffer), -1);
  rb_define_method(SwigClassCapsuleMeshGenerator.klass, "set_utile", VALUEFUNC(_wrap_CapsuleMeshGenerator_set_utile), -1);
  rb_define_method(SwigClassCapsuleMeshGenerator.klass, "set_vtile", VALUEFUNC(_wrap_CapsuleMeshGenerator_set_vtile), -1);
  rb_define_method(SwigClassCapsuleMeshGenerator.klass, "set_texture_rectangle", VALUEFUNC(_wrap_CapsuleMeshGenerator_set_texture_rectangle), -1);
  rb_define_method(SwigClassCapsuleMeshGenerator.klass, "set_enable_normals", VALUEFUNC(_wrap_CapsuleMeshGenerator_set_enable_normals), -1);
  rb_define_method(SwigClassCapsuleMeshGenerator.klass, "set_num_tex_coord_set", VALUEFUNC(_wrap_CapsuleMeshGenerator_set_num_tex_coord_set), -1);
  rb_define_method(SwigClassCapsuleMeshGenerator.klass, "set_switch_uv", VALUEFUNC(_wrap_CapsuleMeshGenerator_set_switch_uv), -1);
  rb_define_method(SwigClassCapsuleMeshGenerator.klass, "set_orientation", VALUEFUNC(_wrap_CapsuleMeshGenerator_set_orientation), -1);
  rb_define_method(SwigClassCapsuleMeshGenerator.klass, "set_position", VALUEFUNC(_wrap_CapsuleMeshGenerator_set_position), -1);
  rb_define_method(SwigClassCapsuleMeshGenerator.klass, "set_scale", VALUEFUNC(_wrap_CapsuleMeshGenerator_set_scale), -1);
  rb_define_method(SwigClassCapsuleMeshGenerator.klass, "reset_transforms", VALUEFUNC(_wrap_CapsuleMeshGenerator_reset_transforms), -1);
  rb_define_method(SwigClassCapsuleMeshGenerator.klass, "_set_dump_to_file", VALUEFUNC(_wrap_CapsuleMeshGenerator__set_dump_to_file), -1);
  rb_define_method(SwigClassCapsuleMeshGenerator.klass, "_disable_dump_to_file", VALUEFUNC(_wrap_CapsuleMeshGenerator__disable_dump_to_file), -1);
  SwigClassCapsuleMeshGenerator.mark = 0;
  SwigClassCapsuleMeshGenerator.destroy = (void (*)(void *)) free_Procedural_MeshGenerator_Sl_Procedural_CapsuleGenerator_Sg_;
  SwigClassCapsuleMeshGenerator.trackObjects = 0;
  
  SwigClassCapsuleGenerator.klass = rb_define_class_under(mProcedural, "CapsuleGenerator", ((swig_class *) SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CapsuleGenerator_t->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__CapsuleGenerator, (void *) &SwigClassCapsuleGenerator);
  rb_define_alloc_func(SwigClassCapsuleGenerator.klass, _wrap_CapsuleGenerator_allocate);
  rb_define_method(SwigClassCapsuleGenerator.klass, "initialize", VALUEFUNC(_wrap_new_CapsuleGenerator), -1);
  rb_define_method(SwigClassCapsuleGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_CapsuleGenerator_add_to_triangle_buffer), -1);
  rb_define_method(SwigClassCapsuleGenerator.klass, "set_radius", VALUEFUNC(_wrap_CapsuleGenerator_set_radius), -1);
  rb_define_method(SwigClassCapsuleGenerator.klass, "set_num_rings", VALUEFUNC(_wrap_CapsuleGenerator_set_num_rings), -1);
  rb_define_method(SwigClassCapsuleGenerator.klass, "set_num_segments", VALUEFUNC(_wrap_CapsuleGenerator_set_num_segments), -1);
  rb_define_method(SwigClassCapsuleGenerator.klass, "set_num_seg_height", VALUEFUNC(_wrap_CapsuleGenerator_set_num_seg_height), -1);
  rb_define_method(SwigClassCapsuleGenerator.klass, "set_height", VALUEFUNC(_wrap_CapsuleGenerator_set_height), -1);
  SwigClassCapsuleGenerator.mark = 0;
  SwigClassCapsuleGenerator.destroy = (void (*)(void *)) free_Procedural_CapsuleGenerator;
  SwigClassCapsuleGenerator.trackObjects = 0;
  
  SwigClassConeMeshGenerator.klass = rb_define_class_under(mProcedural, "ConeMeshGenerator", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t, (void *) &SwigClassConeMeshGenerator);
  rb_undef_alloc_func(SwigClassConeMeshGenerator.klass);
  rb_define_method(SwigClassConeMeshGenerator.klass, "realize_mesh", VALUEFUNC(_wrap_ConeMeshGenerator_realize_mesh), -1);
  rb_define_method(SwigClassConeMeshGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_ConeMeshGenerator_add_to_triangle_buffer), -1);
  rb_define_method(SwigClassConeMeshGenerator.klass, "set_utile", VALUEFUNC(_wrap_ConeMeshGenerator_set_utile), -1);
  rb_define_method(SwigClassConeMeshGenerator.klass, "set_vtile", VALUEFUNC(_wrap_ConeMeshGenerator_set_vtile), -1);
  rb_define_method(SwigClassConeMeshGenerator.klass, "set_texture_rectangle", VALUEFUNC(_wrap_ConeMeshGenerator_set_texture_rectangle), -1);
  rb_define_method(SwigClassConeMeshGenerator.klass, "set_enable_normals", VALUEFUNC(_wrap_ConeMeshGenerator_set_enable_normals), -1);
  rb_define_method(SwigClassConeMeshGenerator.klass, "set_num_tex_coord_set", VALUEFUNC(_wrap_ConeMeshGenerator_set_num_tex_coord_set), -1);
  rb_define_method(SwigClassConeMeshGenerator.klass, "set_switch_uv", VALUEFUNC(_wrap_ConeMeshGenerator_set_switch_uv), -1);
  rb_define_method(SwigClassConeMeshGenerator.klass, "set_orientation", VALUEFUNC(_wrap_ConeMeshGenerator_set_orientation), -1);
  rb_define_method(SwigClassConeMeshGenerator.klass, "set_position", VALUEFUNC(_wrap_ConeMeshGenerator_set_position), -1);
  rb_define_method(SwigClassConeMeshGenerator.klass, "set_scale", VALUEFUNC(_wrap_ConeMeshGenerator_set_scale), -1);
  rb_define_method(SwigClassConeMeshGenerator.klass, "reset_transforms", VALUEFUNC(_wrap_ConeMeshGenerator_reset_transforms), -1);
  rb_define_method(SwigClassConeMeshGenerator.klass, "_set_dump_to_file", VALUEFUNC(_wrap_ConeMeshGenerator__set_dump_to_file), -1);
  rb_define_method(SwigClassConeMeshGenerator.klass, "_disable_dump_to_file", VALUEFUNC(_wrap_ConeMeshGenerator__disable_dump_to_file), -1);
  SwigClassConeMeshGenerator.mark = 0;
  SwigClassConeMeshGenerator.destroy = (void (*)(void *)) free_Procedural_MeshGenerator_Sl_Procedural_ConeGenerator_Sg_;
  SwigClassConeMeshGenerator.trackObjects = 0;
  
  SwigClassConeGenerator.klass = rb_define_class_under(mProcedural, "ConeGenerator", ((swig_class *) SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__ConeGenerator_t->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__ConeGenerator, (void *) &SwigClassConeGenerator);
  rb_define_alloc_func(SwigClassConeGenerator.klass, _wrap_ConeGenerator_allocate);
  rb_define_method(SwigClassConeGenerator.klass, "initialize", VALUEFUNC(_wrap_new_ConeGenerator), -1);
  rb_define_method(SwigClassConeGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_ConeGenerator_add_to_triangle_buffer), -1);
  rb_define_method(SwigClassConeGenerator.klass, "set_num_seg_base", VALUEFUNC(_wrap_ConeGenerator_set_num_seg_base), -1);
  rb_define_method(SwigClassConeGenerator.klass, "set_num_seg_height", VALUEFUNC(_wrap_ConeGenerator_set_num_seg_height), -1);
  rb_define_method(SwigClassConeGenerator.klass, "set_radius", VALUEFUNC(_wrap_ConeGenerator_set_radius), -1);
  rb_define_method(SwigClassConeGenerator.klass, "set_height", VALUEFUNC(_wrap_ConeGenerator_set_height), -1);
  SwigClassConeGenerator.mark = 0;
  SwigClassConeGenerator.destroy = (void (*)(void *)) free_Procedural_ConeGenerator;
  SwigClassConeGenerator.trackObjects = 0;
  
  SwigClassCylinderMeshGenerator.klass = rb_define_class_under(mProcedural, "CylinderMeshGenerator", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t, (void *) &SwigClassCylinderMeshGenerator);
  rb_undef_alloc_func(SwigClassCylinderMeshGenerator.klass);
  rb_define_method(SwigClassCylinderMeshGenerator.klass, "realize_mesh", VALUEFUNC(_wrap_CylinderMeshGenerator_realize_mesh), -1);
  rb_define_method(SwigClassCylinderMeshGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_CylinderMeshGenerator_add_to_triangle_buffer), -1);
  rb_define_method(SwigClassCylinderMeshGenerator.klass, "set_utile", VALUEFUNC(_wrap_CylinderMeshGenerator_set_utile), -1);
  rb_define_method(SwigClassCylinderMeshGenerator.klass, "set_vtile", VALUEFUNC(_wrap_CylinderMeshGenerator_set_vtile), -1);
  rb_define_method(SwigClassCylinderMeshGenerator.klass, "set_texture_rectangle", VALUEFUNC(_wrap_CylinderMeshGenerator_set_texture_rectangle), -1);
  rb_define_method(SwigClassCylinderMeshGenerator.klass, "set_enable_normals", VALUEFUNC(_wrap_CylinderMeshGenerator_set_enable_normals), -1);
  rb_define_method(SwigClassCylinderMeshGenerator.klass, "set_num_tex_coord_set", VALUEFUNC(_wrap_CylinderMeshGenerator_set_num_tex_coord_set), -1);
  rb_define_method(SwigClassCylinderMeshGenerator.klass, "set_switch_uv", VALUEFUNC(_wrap_CylinderMeshGenerator_set_switch_uv), -1);
  rb_define_method(SwigClassCylinderMeshGenerator.klass, "set_orientation", VALUEFUNC(_wrap_CylinderMeshGenerator_set_orientation), -1);
  rb_define_method(SwigClassCylinderMeshGenerator.klass, "set_position", VALUEFUNC(_wrap_CylinderMeshGenerator_set_position), -1);
  rb_define_method(SwigClassCylinderMeshGenerator.klass, "set_scale", VALUEFUNC(_wrap_CylinderMeshGenerator_set_scale), -1);
  rb_define_method(SwigClassCylinderMeshGenerator.klass, "reset_transforms", VALUEFUNC(_wrap_CylinderMeshGenerator_reset_transforms), -1);
  rb_define_method(SwigClassCylinderMeshGenerator.klass, "_set_dump_to_file", VALUEFUNC(_wrap_CylinderMeshGenerator__set_dump_to_file), -1);
  rb_define_method(SwigClassCylinderMeshGenerator.klass, "_disable_dump_to_file", VALUEFUNC(_wrap_CylinderMeshGenerator__disable_dump_to_file), -1);
  SwigClassCylinderMeshGenerator.mark = 0;
  SwigClassCylinderMeshGenerator.destroy = (void (*)(void *)) free_Procedural_MeshGenerator_Sl_Procedural_CylinderGenerator_Sg_;
  SwigClassCylinderMeshGenerator.trackObjects = 0;
  
  SwigClassCylinderGenerator.klass = rb_define_class_under(mProcedural, "CylinderGenerator", ((swig_class *) SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__CylinderGenerator_t->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__CylinderGenerator, (void *) &SwigClassCylinderGenerator);
  rb_define_alloc_func(SwigClassCylinderGenerator.klass, _wrap_CylinderGenerator_allocate);
  rb_define_method(SwigClassCylinderGenerator.klass, "initialize", VALUEFUNC(_wrap_new_CylinderGenerator), -1);
  rb_define_method(SwigClassCylinderGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_CylinderGenerator_add_to_triangle_buffer), -1);
  rb_define_method(SwigClassCylinderGenerator.klass, "set_num_seg_base", VALUEFUNC(_wrap_CylinderGenerator_set_num_seg_base), -1);
  rb_define_method(SwigClassCylinderGenerator.klass, "set_num_seg_height", VALUEFUNC(_wrap_CylinderGenerator_set_num_seg_height), -1);
  rb_define_method(SwigClassCylinderGenerator.klass, "set_capped", VALUEFUNC(_wrap_CylinderGenerator_set_capped), -1);
  rb_define_method(SwigClassCylinderGenerator.klass, "set_radius", VALUEFUNC(_wrap_CylinderGenerator_set_radius), -1);
  rb_define_method(SwigClassCylinderGenerator.klass, "set_height", VALUEFUNC(_wrap_CylinderGenerator_set_height), -1);
  SwigClassCylinderGenerator.mark = 0;
  SwigClassCylinderGenerator.destroy = (void (*)(void *)) free_Procedural_CylinderGenerator;
  SwigClassCylinderGenerator.trackObjects = 0;
  
  SwigClassIcoSphereMeshGenerator.klass = rb_define_class_under(mProcedural, "IcoSphereMeshGenerator", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t, (void *) &SwigClassIcoSphereMeshGenerator);
  rb_undef_alloc_func(SwigClassIcoSphereMeshGenerator.klass);
  rb_define_method(SwigClassIcoSphereMeshGenerator.klass, "realize_mesh", VALUEFUNC(_wrap_IcoSphereMeshGenerator_realize_mesh), -1);
  rb_define_method(SwigClassIcoSphereMeshGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_IcoSphereMeshGenerator_add_to_triangle_buffer), -1);
  rb_define_method(SwigClassIcoSphereMeshGenerator.klass, "set_utile", VALUEFUNC(_wrap_IcoSphereMeshGenerator_set_utile), -1);
  rb_define_method(SwigClassIcoSphereMeshGenerator.klass, "set_vtile", VALUEFUNC(_wrap_IcoSphereMeshGenerator_set_vtile), -1);
  rb_define_method(SwigClassIcoSphereMeshGenerator.klass, "set_texture_rectangle", VALUEFUNC(_wrap_IcoSphereMeshGenerator_set_texture_rectangle), -1);
  rb_define_method(SwigClassIcoSphereMeshGenerator.klass, "set_enable_normals", VALUEFUNC(_wrap_IcoSphereMeshGenerator_set_enable_normals), -1);
  rb_define_method(SwigClassIcoSphereMeshGenerator.klass, "set_num_tex_coord_set", VALUEFUNC(_wrap_IcoSphereMeshGenerator_set_num_tex_coord_set), -1);
  rb_define_method(SwigClassIcoSphereMeshGenerator.klass, "set_switch_uv", VALUEFUNC(_wrap_IcoSphereMeshGenerator_set_switch_uv), -1);
  rb_define_method(SwigClassIcoSphereMeshGenerator.klass, "set_orientation", VALUEFUNC(_wrap_IcoSphereMeshGenerator_set_orientation), -1);
  rb_define_method(SwigClassIcoSphereMeshGenerator.klass, "set_position", VALUEFUNC(_wrap_IcoSphereMeshGenerator_set_position), -1);
  rb_define_method(SwigClassIcoSphereMeshGenerator.klass, "set_scale", VALUEFUNC(_wrap_IcoSphereMeshGenerator_set_scale), -1);
  rb_define_method(SwigClassIcoSphereMeshGenerator.klass, "reset_transforms", VALUEFUNC(_wrap_IcoSphereMeshGenerator_reset_transforms), -1);
  rb_define_method(SwigClassIcoSphereMeshGenerator.klass, "_set_dump_to_file", VALUEFUNC(_wrap_IcoSphereMeshGenerator__set_dump_to_file), -1);
  rb_define_method(SwigClassIcoSphereMeshGenerator.klass, "_disable_dump_to_file", VALUEFUNC(_wrap_IcoSphereMeshGenerator__disable_dump_to_file), -1);
  SwigClassIcoSphereMeshGenerator.mark = 0;
  SwigClassIcoSphereMeshGenerator.destroy = (void (*)(void *)) free_Procedural_MeshGenerator_Sl_Procedural_IcoSphereGenerator_Sg_;
  SwigClassIcoSphereMeshGenerator.trackObjects = 0;
  
  SwigClassIcoSphereGenerator.klass = rb_define_class_under(mProcedural, "IcoSphereGenerator", ((swig_class *) SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__IcoSphereGenerator_t->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__IcoSphereGenerator, (void *) &SwigClassIcoSphereGenerator);
  rb_define_alloc_func(SwigClassIcoSphereGenerator.klass, _wrap_IcoSphereGenerator_allocate);
  rb_define_method(SwigClassIcoSphereGenerator.klass, "initialize", VALUEFUNC(_wrap_new_IcoSphereGenerator), -1);
  rb_define_method(SwigClassIcoSphereGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_IcoSphereGenerator_add_to_triangle_buffer), -1);
  rb_define_method(SwigClassIcoSphereGenerator.klass, "set_radius", VALUEFUNC(_wrap_IcoSphereGenerator_set_radius), -1);
  rb_define_method(SwigClassIcoSphereGenerator.klass, "set_num_iterations", VALUEFUNC(_wrap_IcoSphereGenerator_set_num_iterations), -1);
  SwigClassIcoSphereGenerator.mark = 0;
  SwigClassIcoSphereGenerator.destroy = (void (*)(void *)) free_Procedural_IcoSphereGenerator;
  SwigClassIcoSphereGenerator.trackObjects = 0;
  
  SwigClassMultiShape.klass = rb_define_class_under(mProcedural, "MultiShape", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__MultiShape, (void *) &SwigClassMultiShape);
  rb_define_alloc_func(SwigClassMultiShape.klass, _wrap_MultiShape_allocate);
  rb_define_method(SwigClassMultiShape.klass, "initialize", VALUEFUNC(_wrap_new_MultiShape), -1);
  rb_define_method(SwigClassMultiShape.klass, "add_shape", VALUEFUNC(_wrap_MultiShape_add_shape), -1);
  rb_define_method(SwigClassMultiShape.klass, "get_shape", VALUEFUNC(_wrap_MultiShape_get_shape), -1);
  rb_define_method(SwigClassMultiShape.klass, "get_points", VALUEFUNC(_wrap_MultiShape_get_points), -1);
  rb_define_method(SwigClassMultiShape.klass, "get_shape_count", VALUEFUNC(_wrap_MultiShape_get_shape_count), -1);
  rb_define_method(SwigClassMultiShape.klass, "add_multi_shape", VALUEFUNC(_wrap_MultiShape_add_multi_shape), -1);
  rb_define_method(SwigClassMultiShape.klass, "realize_mesh", VALUEFUNC(_wrap_MultiShape_realize_mesh), -1);
  rb_define_method(SwigClassMultiShape.klass, "is_point_inside", VALUEFUNC(_wrap_MultiShape_is_point_inside), -1);
  rb_define_method(SwigClassMultiShape.klass, "is_closed", VALUEFUNC(_wrap_MultiShape_is_closed), -1);
  rb_define_method(SwigClassMultiShape.klass, "close", VALUEFUNC(_wrap_MultiShape_close), -1);
  rb_define_method(SwigClassMultiShape.klass, "is_outside_real_outside", VALUEFUNC(_wrap_MultiShape_is_outside_real_outside), -1);
  SwigClassMultiShape.mark = 0;
  SwigClassMultiShape.destroy = (void (*)(void *)) free_Procedural_MultiShape;
  SwigClassMultiShape.trackObjects = 0;
  
  SwigClassPlaneMeshGenerator.klass = rb_define_class_under(mProcedural, "PlaneMeshGenerator", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t, (void *) &SwigClassPlaneMeshGenerator);
  rb_undef_alloc_func(SwigClassPlaneMeshGenerator.klass);
  rb_define_method(SwigClassPlaneMeshGenerator.klass, "realize_mesh", VALUEFUNC(_wrap_PlaneMeshGenerator_realize_mesh), -1);
  rb_define_method(SwigClassPlaneMeshGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_PlaneMeshGenerator_add_to_triangle_buffer), -1);
  rb_define_method(SwigClassPlaneMeshGenerator.klass, "set_utile", VALUEFUNC(_wrap_PlaneMeshGenerator_set_utile), -1);
  rb_define_method(SwigClassPlaneMeshGenerator.klass, "set_vtile", VALUEFUNC(_wrap_PlaneMeshGenerator_set_vtile), -1);
  rb_define_method(SwigClassPlaneMeshGenerator.klass, "set_texture_rectangle", VALUEFUNC(_wrap_PlaneMeshGenerator_set_texture_rectangle), -1);
  rb_define_method(SwigClassPlaneMeshGenerator.klass, "set_enable_normals", VALUEFUNC(_wrap_PlaneMeshGenerator_set_enable_normals), -1);
  rb_define_method(SwigClassPlaneMeshGenerator.klass, "set_num_tex_coord_set", VALUEFUNC(_wrap_PlaneMeshGenerator_set_num_tex_coord_set), -1);
  rb_define_method(SwigClassPlaneMeshGenerator.klass, "set_switch_uv", VALUEFUNC(_wrap_PlaneMeshGenerator_set_switch_uv), -1);
  rb_define_method(SwigClassPlaneMeshGenerator.klass, "set_orientation", VALUEFUNC(_wrap_PlaneMeshGenerator_set_orientation), -1);
  rb_define_method(SwigClassPlaneMeshGenerator.klass, "set_position", VALUEFUNC(_wrap_PlaneMeshGenerator_set_position), -1);
  rb_define_method(SwigClassPlaneMeshGenerator.klass, "set_scale", VALUEFUNC(_wrap_PlaneMeshGenerator_set_scale), -1);
  rb_define_method(SwigClassPlaneMeshGenerator.klass, "reset_transforms", VALUEFUNC(_wrap_PlaneMeshGenerator_reset_transforms), -1);
  rb_define_method(SwigClassPlaneMeshGenerator.klass, "_set_dump_to_file", VALUEFUNC(_wrap_PlaneMeshGenerator__set_dump_to_file), -1);
  rb_define_method(SwigClassPlaneMeshGenerator.klass, "_disable_dump_to_file", VALUEFUNC(_wrap_PlaneMeshGenerator__disable_dump_to_file), -1);
  SwigClassPlaneMeshGenerator.mark = 0;
  SwigClassPlaneMeshGenerator.destroy = (void (*)(void *)) free_Procedural_MeshGenerator_Sl_Procedural_PlaneGenerator_Sg_;
  SwigClassPlaneMeshGenerator.trackObjects = 0;
  
  SwigClassPlaneGenerator.klass = rb_define_class_under(mProcedural, "PlaneGenerator", ((swig_class *) SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__PlaneGenerator_t->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__PlaneGenerator, (void *) &SwigClassPlaneGenerator);
  rb_define_alloc_func(SwigClassPlaneGenerator.klass, _wrap_PlaneGenerator_allocate);
  rb_define_method(SwigClassPlaneGenerator.klass, "initialize", VALUEFUNC(_wrap_new_PlaneGenerator), -1);
  rb_define_method(SwigClassPlaneGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_PlaneGenerator_add_to_triangle_buffer), -1);
  rb_define_method(SwigClassPlaneGenerator.klass, "set_num_seg_x", VALUEFUNC(_wrap_PlaneGenerator_set_num_seg_x), -1);
  rb_define_method(SwigClassPlaneGenerator.klass, "set_num_seg_y", VALUEFUNC(_wrap_PlaneGenerator_set_num_seg_y), -1);
  rb_define_method(SwigClassPlaneGenerator.klass, "set_normal", VALUEFUNC(_wrap_PlaneGenerator_set_normal), -1);
  rb_define_method(SwigClassPlaneGenerator.klass, "set_size_x", VALUEFUNC(_wrap_PlaneGenerator_set_size_x), -1);
  rb_define_method(SwigClassPlaneGenerator.klass, "set_size_y", VALUEFUNC(_wrap_PlaneGenerator_set_size_y), -1);
  SwigClassPlaneGenerator.mark = 0;
  SwigClassPlaneGenerator.destroy = (void (*)(void *)) free_Procedural_PlaneGenerator;
  SwigClassPlaneGenerator.trackObjects = 0;
  
  SwigClassRoundedBoxMeshGenerator.klass = rb_define_class_under(mProcedural, "RoundedBoxMeshGenerator", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t, (void *) &SwigClassRoundedBoxMeshGenerator);
  rb_undef_alloc_func(SwigClassRoundedBoxMeshGenerator.klass);
  rb_define_method(SwigClassRoundedBoxMeshGenerator.klass, "realize_mesh", VALUEFUNC(_wrap_RoundedBoxMeshGenerator_realize_mesh), -1);
  rb_define_method(SwigClassRoundedBoxMeshGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_RoundedBoxMeshGenerator_add_to_triangle_buffer), -1);
  rb_define_method(SwigClassRoundedBoxMeshGenerator.klass, "set_utile", VALUEFUNC(_wrap_RoundedBoxMeshGenerator_set_utile), -1);
  rb_define_method(SwigClassRoundedBoxMeshGenerator.klass, "set_vtile", VALUEFUNC(_wrap_RoundedBoxMeshGenerator_set_vtile), -1);
  rb_define_method(SwigClassRoundedBoxMeshGenerator.klass, "set_texture_rectangle", VALUEFUNC(_wrap_RoundedBoxMeshGenerator_set_texture_rectangle), -1);
  rb_define_method(SwigClassRoundedBoxMeshGenerator.klass, "set_enable_normals", VALUEFUNC(_wrap_RoundedBoxMeshGenerator_set_enable_normals), -1);
  rb_define_method(SwigClassRoundedBoxMeshGenerator.klass, "set_num_tex_coord_set", VALUEFUNC(_wrap_RoundedBoxMeshGenerator_set_num_tex_coord_set), -1);
  rb_define_method(SwigClassRoundedBoxMeshGenerator.klass, "set_switch_uv", VALUEFUNC(_wrap_RoundedBoxMeshGenerator_set_switch_uv), -1);
  rb_define_method(SwigClassRoundedBoxMeshGenerator.klass, "set_orientation", VALUEFUNC(_wrap_RoundedBoxMeshGenerator_set_orientation), -1);
  rb_define_method(SwigClassRoundedBoxMeshGenerator.klass, "set_position", VALUEFUNC(_wrap_RoundedBoxMeshGenerator_set_position), -1);
  rb_define_method(SwigClassRoundedBoxMeshGenerator.klass, "set_scale", VALUEFUNC(_wrap_RoundedBoxMeshGenerator_set_scale), -1);
  rb_define_method(SwigClassRoundedBoxMeshGenerator.klass, "reset_transforms", VALUEFUNC(_wrap_RoundedBoxMeshGenerator_reset_transforms), -1);
  rb_define_method(SwigClassRoundedBoxMeshGenerator.klass, "_set_dump_to_file", VALUEFUNC(_wrap_RoundedBoxMeshGenerator__set_dump_to_file), -1);
  rb_define_method(SwigClassRoundedBoxMeshGenerator.klass, "_disable_dump_to_file", VALUEFUNC(_wrap_RoundedBoxMeshGenerator__disable_dump_to_file), -1);
  SwigClassRoundedBoxMeshGenerator.mark = 0;
  SwigClassRoundedBoxMeshGenerator.destroy = (void (*)(void *)) free_Procedural_MeshGenerator_Sl_Procedural_RoundedBoxGenerator_Sg_;
  SwigClassRoundedBoxMeshGenerator.trackObjects = 0;
  
  SwigClassRoundedBoxGenerator.klass = rb_define_class_under(mProcedural, "RoundedBoxGenerator", ((swig_class *) SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__RoundedBoxGenerator_t->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__RoundedBoxGenerator, (void *) &SwigClassRoundedBoxGenerator);
  rb_define_alloc_func(SwigClassRoundedBoxGenerator.klass, _wrap_RoundedBoxGenerator_allocate);
  rb_define_method(SwigClassRoundedBoxGenerator.klass, "initialize", VALUEFUNC(_wrap_new_RoundedBoxGenerator), -1);
  rb_define_method(SwigClassRoundedBoxGenerator.klass, "set_size_x", VALUEFUNC(_wrap_RoundedBoxGenerator_set_size_x), -1);
  rb_define_method(SwigClassRoundedBoxGenerator.klass, "set_size_y", VALUEFUNC(_wrap_RoundedBoxGenerator_set_size_y), -1);
  rb_define_method(SwigClassRoundedBoxGenerator.klass, "set_size_z", VALUEFUNC(_wrap_RoundedBoxGenerator_set_size_z), -1);
  rb_define_method(SwigClassRoundedBoxGenerator.klass, "set_num_seg_x", VALUEFUNC(_wrap_RoundedBoxGenerator_set_num_seg_x), -1);
  rb_define_method(SwigClassRoundedBoxGenerator.klass, "set_num_seg_y", VALUEFUNC(_wrap_RoundedBoxGenerator_set_num_seg_y), -1);
  rb_define_method(SwigClassRoundedBoxGenerator.klass, "set_num_seg_z", VALUEFUNC(_wrap_RoundedBoxGenerator_set_num_seg_z), -1);
  rb_define_method(SwigClassRoundedBoxGenerator.klass, "set_chamfer_size", VALUEFUNC(_wrap_RoundedBoxGenerator_set_chamfer_size), -1);
  rb_define_method(SwigClassRoundedBoxGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_RoundedBoxGenerator_add_to_triangle_buffer), -1);
  SwigClassRoundedBoxGenerator.mark = 0;
  SwigClassRoundedBoxGenerator.destroy = (void (*)(void *)) free_Procedural_RoundedBoxGenerator;
  SwigClassRoundedBoxGenerator.trackObjects = 0;
  
  SwigClassSphereMeshGenerator.klass = rb_define_class_under(mProcedural, "SphereMeshGenerator", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t, (void *) &SwigClassSphereMeshGenerator);
  rb_undef_alloc_func(SwigClassSphereMeshGenerator.klass);
  rb_define_method(SwigClassSphereMeshGenerator.klass, "realize_mesh", VALUEFUNC(_wrap_SphereMeshGenerator_realize_mesh), -1);
  rb_define_method(SwigClassSphereMeshGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_SphereMeshGenerator_add_to_triangle_buffer), -1);
  rb_define_method(SwigClassSphereMeshGenerator.klass, "set_utile", VALUEFUNC(_wrap_SphereMeshGenerator_set_utile), -1);
  rb_define_method(SwigClassSphereMeshGenerator.klass, "set_vtile", VALUEFUNC(_wrap_SphereMeshGenerator_set_vtile), -1);
  rb_define_method(SwigClassSphereMeshGenerator.klass, "set_texture_rectangle", VALUEFUNC(_wrap_SphereMeshGenerator_set_texture_rectangle), -1);
  rb_define_method(SwigClassSphereMeshGenerator.klass, "set_enable_normals", VALUEFUNC(_wrap_SphereMeshGenerator_set_enable_normals), -1);
  rb_define_method(SwigClassSphereMeshGenerator.klass, "set_num_tex_coord_set", VALUEFUNC(_wrap_SphereMeshGenerator_set_num_tex_coord_set), -1);
  rb_define_method(SwigClassSphereMeshGenerator.klass, "set_switch_uv", VALUEFUNC(_wrap_SphereMeshGenerator_set_switch_uv), -1);
  rb_define_method(SwigClassSphereMeshGenerator.klass, "set_orientation", VALUEFUNC(_wrap_SphereMeshGenerator_set_orientation), -1);
  rb_define_method(SwigClassSphereMeshGenerator.klass, "set_position", VALUEFUNC(_wrap_SphereMeshGenerator_set_position), -1);
  rb_define_method(SwigClassSphereMeshGenerator.klass, "set_scale", VALUEFUNC(_wrap_SphereMeshGenerator_set_scale), -1);
  rb_define_method(SwigClassSphereMeshGenerator.klass, "reset_transforms", VALUEFUNC(_wrap_SphereMeshGenerator_reset_transforms), -1);
  rb_define_method(SwigClassSphereMeshGenerator.klass, "_set_dump_to_file", VALUEFUNC(_wrap_SphereMeshGenerator__set_dump_to_file), -1);
  rb_define_method(SwigClassSphereMeshGenerator.klass, "_disable_dump_to_file", VALUEFUNC(_wrap_SphereMeshGenerator__disable_dump_to_file), -1);
  SwigClassSphereMeshGenerator.mark = 0;
  SwigClassSphereMeshGenerator.destroy = (void (*)(void *)) free_Procedural_MeshGenerator_Sl_Procedural_SphereGenerator_Sg_;
  SwigClassSphereMeshGenerator.trackObjects = 0;
  
  SwigClassSphereGenerator.klass = rb_define_class_under(mProcedural, "SphereGenerator", ((swig_class *) SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__SphereGenerator_t->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__SphereGenerator, (void *) &SwigClassSphereGenerator);
  rb_define_alloc_func(SwigClassSphereGenerator.klass, _wrap_SphereGenerator_allocate);
  rb_define_method(SwigClassSphereGenerator.klass, "initialize", VALUEFUNC(_wrap_new_SphereGenerator), -1);
  rb_define_method(SwigClassSphereGenerator.klass, "set_radius", VALUEFUNC(_wrap_SphereGenerator_set_radius), -1);
  rb_define_method(SwigClassSphereGenerator.klass, "set_num_rings", VALUEFUNC(_wrap_SphereGenerator_set_num_rings), -1);
  rb_define_method(SwigClassSphereGenerator.klass, "set_num_segments", VALUEFUNC(_wrap_SphereGenerator_set_num_segments), -1);
  rb_define_method(SwigClassSphereGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_SphereGenerator_add_to_triangle_buffer), -1);
  SwigClassSphereGenerator.mark = 0;
  SwigClassSphereGenerator.destroy = (void (*)(void *)) free_Procedural_SphereGenerator;
  SwigClassSphereGenerator.trackObjects = 0;
  
  SwigClassTorusMeshGenerator.klass = rb_define_class_under(mProcedural, "TorusMeshGenerator", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t, (void *) &SwigClassTorusMeshGenerator);
  rb_undef_alloc_func(SwigClassTorusMeshGenerator.klass);
  rb_define_method(SwigClassTorusMeshGenerator.klass, "realize_mesh", VALUEFUNC(_wrap_TorusMeshGenerator_realize_mesh), -1);
  rb_define_method(SwigClassTorusMeshGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_TorusMeshGenerator_add_to_triangle_buffer), -1);
  rb_define_method(SwigClassTorusMeshGenerator.klass, "set_utile", VALUEFUNC(_wrap_TorusMeshGenerator_set_utile), -1);
  rb_define_method(SwigClassTorusMeshGenerator.klass, "set_vtile", VALUEFUNC(_wrap_TorusMeshGenerator_set_vtile), -1);
  rb_define_method(SwigClassTorusMeshGenerator.klass, "set_texture_rectangle", VALUEFUNC(_wrap_TorusMeshGenerator_set_texture_rectangle), -1);
  rb_define_method(SwigClassTorusMeshGenerator.klass, "set_enable_normals", VALUEFUNC(_wrap_TorusMeshGenerator_set_enable_normals), -1);
  rb_define_method(SwigClassTorusMeshGenerator.klass, "set_num_tex_coord_set", VALUEFUNC(_wrap_TorusMeshGenerator_set_num_tex_coord_set), -1);
  rb_define_method(SwigClassTorusMeshGenerator.klass, "set_switch_uv", VALUEFUNC(_wrap_TorusMeshGenerator_set_switch_uv), -1);
  rb_define_method(SwigClassTorusMeshGenerator.klass, "set_orientation", VALUEFUNC(_wrap_TorusMeshGenerator_set_orientation), -1);
  rb_define_method(SwigClassTorusMeshGenerator.klass, "set_position", VALUEFUNC(_wrap_TorusMeshGenerator_set_position), -1);
  rb_define_method(SwigClassTorusMeshGenerator.klass, "set_scale", VALUEFUNC(_wrap_TorusMeshGenerator_set_scale), -1);
  rb_define_method(SwigClassTorusMeshGenerator.klass, "reset_transforms", VALUEFUNC(_wrap_TorusMeshGenerator_reset_transforms), -1);
  rb_define_method(SwigClassTorusMeshGenerator.klass, "_set_dump_to_file", VALUEFUNC(_wrap_TorusMeshGenerator__set_dump_to_file), -1);
  rb_define_method(SwigClassTorusMeshGenerator.klass, "_disable_dump_to_file", VALUEFUNC(_wrap_TorusMeshGenerator__disable_dump_to_file), -1);
  SwigClassTorusMeshGenerator.mark = 0;
  SwigClassTorusMeshGenerator.destroy = (void (*)(void *)) free_Procedural_MeshGenerator_Sl_Procedural_TorusGenerator_Sg_;
  SwigClassTorusMeshGenerator.trackObjects = 0;
  
  SwigClassTorusGenerator.klass = rb_define_class_under(mProcedural, "TorusGenerator", ((swig_class *) SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusGenerator_t->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__TorusGenerator, (void *) &SwigClassTorusGenerator);
  rb_define_alloc_func(SwigClassTorusGenerator.klass, _wrap_TorusGenerator_allocate);
  rb_define_method(SwigClassTorusGenerator.klass, "initialize", VALUEFUNC(_wrap_new_TorusGenerator), -1);
  rb_define_method(SwigClassTorusGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_TorusGenerator_add_to_triangle_buffer), -1);
  rb_define_method(SwigClassTorusGenerator.klass, "set_num_seg_section", VALUEFUNC(_wrap_TorusGenerator_set_num_seg_section), -1);
  rb_define_method(SwigClassTorusGenerator.klass, "set_num_seg_circle", VALUEFUNC(_wrap_TorusGenerator_set_num_seg_circle), -1);
  rb_define_method(SwigClassTorusGenerator.klass, "set_radius", VALUEFUNC(_wrap_TorusGenerator_set_radius), -1);
  rb_define_method(SwigClassTorusGenerator.klass, "set_section_radius", VALUEFUNC(_wrap_TorusGenerator_set_section_radius), -1);
  SwigClassTorusGenerator.mark = 0;
  SwigClassTorusGenerator.destroy = (void (*)(void *)) free_Procedural_TorusGenerator;
  SwigClassTorusGenerator.trackObjects = 0;
  
  SwigClassTorusKnotMeshGenerator.klass = rb_define_class_under(mProcedural, "TorusKnotMeshGenerator", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t, (void *) &SwigClassTorusKnotMeshGenerator);
  rb_undef_alloc_func(SwigClassTorusKnotMeshGenerator.klass);
  rb_define_method(SwigClassTorusKnotMeshGenerator.klass, "realize_mesh", VALUEFUNC(_wrap_TorusKnotMeshGenerator_realize_mesh), -1);
  rb_define_method(SwigClassTorusKnotMeshGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_TorusKnotMeshGenerator_add_to_triangle_buffer), -1);
  rb_define_method(SwigClassTorusKnotMeshGenerator.klass, "set_utile", VALUEFUNC(_wrap_TorusKnotMeshGenerator_set_utile), -1);
  rb_define_method(SwigClassTorusKnotMeshGenerator.klass, "set_vtile", VALUEFUNC(_wrap_TorusKnotMeshGenerator_set_vtile), -1);
  rb_define_method(SwigClassTorusKnotMeshGenerator.klass, "set_texture_rectangle", VALUEFUNC(_wrap_TorusKnotMeshGenerator_set_texture_rectangle), -1);
  rb_define_method(SwigClassTorusKnotMeshGenerator.klass, "set_enable_normals", VALUEFUNC(_wrap_TorusKnotMeshGenerator_set_enable_normals), -1);
  rb_define_method(SwigClassTorusKnotMeshGenerator.klass, "set_num_tex_coord_set", VALUEFUNC(_wrap_TorusKnotMeshGenerator_set_num_tex_coord_set), -1);
  rb_define_method(SwigClassTorusKnotMeshGenerator.klass, "set_switch_uv", VALUEFUNC(_wrap_TorusKnotMeshGenerator_set_switch_uv), -1);
  rb_define_method(SwigClassTorusKnotMeshGenerator.klass, "set_orientation", VALUEFUNC(_wrap_TorusKnotMeshGenerator_set_orientation), -1);
  rb_define_method(SwigClassTorusKnotMeshGenerator.klass, "set_position", VALUEFUNC(_wrap_TorusKnotMeshGenerator_set_position), -1);
  rb_define_method(SwigClassTorusKnotMeshGenerator.klass, "set_scale", VALUEFUNC(_wrap_TorusKnotMeshGenerator_set_scale), -1);
  rb_define_method(SwigClassTorusKnotMeshGenerator.klass, "reset_transforms", VALUEFUNC(_wrap_TorusKnotMeshGenerator_reset_transforms), -1);
  rb_define_method(SwigClassTorusKnotMeshGenerator.klass, "_set_dump_to_file", VALUEFUNC(_wrap_TorusKnotMeshGenerator__set_dump_to_file), -1);
  rb_define_method(SwigClassTorusKnotMeshGenerator.klass, "_disable_dump_to_file", VALUEFUNC(_wrap_TorusKnotMeshGenerator__disable_dump_to_file), -1);
  SwigClassTorusKnotMeshGenerator.mark = 0;
  SwigClassTorusKnotMeshGenerator.destroy = (void (*)(void *)) free_Procedural_MeshGenerator_Sl_Procedural_TorusKnotGenerator_Sg_;
  SwigClassTorusKnotMeshGenerator.trackObjects = 0;
  
  SwigClassTorusKnotGenerator.klass = rb_define_class_under(mProcedural, "TorusKnotGenerator", ((swig_class *) SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TorusKnotGenerator_t->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__TorusKnotGenerator, (void *) &SwigClassTorusKnotGenerator);
  rb_define_alloc_func(SwigClassTorusKnotGenerator.klass, _wrap_TorusKnotGenerator_allocate);
  rb_define_method(SwigClassTorusKnotGenerator.klass, "initialize", VALUEFUNC(_wrap_new_TorusKnotGenerator), -1);
  rb_define_method(SwigClassTorusKnotGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_TorusKnotGenerator_add_to_triangle_buffer), -1);
  rb_define_method(SwigClassTorusKnotGenerator.klass, "set_num_seg_section", VALUEFUNC(_wrap_TorusKnotGenerator_set_num_seg_section), -1);
  rb_define_method(SwigClassTorusKnotGenerator.klass, "set_num_seg_circle", VALUEFUNC(_wrap_TorusKnotGenerator_set_num_seg_circle), -1);
  rb_define_method(SwigClassTorusKnotGenerator.klass, "set_radius", VALUEFUNC(_wrap_TorusKnotGenerator_set_radius), -1);
  rb_define_method(SwigClassTorusKnotGenerator.klass, "set_section_radius", VALUEFUNC(_wrap_TorusKnotGenerator_set_section_radius), -1);
  rb_define_method(SwigClassTorusKnotGenerator.klass, "set_p", VALUEFUNC(_wrap_TorusKnotGenerator_set_p), -1);
  rb_define_method(SwigClassTorusKnotGenerator.klass, "set_q", VALUEFUNC(_wrap_TorusKnotGenerator_set_q), -1);
  SwigClassTorusKnotGenerator.mark = 0;
  SwigClassTorusKnotGenerator.destroy = (void (*)(void *)) free_Procedural_TorusKnotGenerator;
  SwigClassTorusKnotGenerator.trackObjects = 0;
  
  SwigClassTubeMeshGenerator.klass = rb_define_class_under(mProcedural, "TubeMeshGenerator", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t, (void *) &SwigClassTubeMeshGenerator);
  rb_undef_alloc_func(SwigClassTubeMeshGenerator.klass);
  rb_define_method(SwigClassTubeMeshGenerator.klass, "realize_mesh", VALUEFUNC(_wrap_TubeMeshGenerator_realize_mesh), -1);
  rb_define_method(SwigClassTubeMeshGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_TubeMeshGenerator_add_to_triangle_buffer), -1);
  rb_define_method(SwigClassTubeMeshGenerator.klass, "set_utile", VALUEFUNC(_wrap_TubeMeshGenerator_set_utile), -1);
  rb_define_method(SwigClassTubeMeshGenerator.klass, "set_vtile", VALUEFUNC(_wrap_TubeMeshGenerator_set_vtile), -1);
  rb_define_method(SwigClassTubeMeshGenerator.klass, "set_texture_rectangle", VALUEFUNC(_wrap_TubeMeshGenerator_set_texture_rectangle), -1);
  rb_define_method(SwigClassTubeMeshGenerator.klass, "set_enable_normals", VALUEFUNC(_wrap_TubeMeshGenerator_set_enable_normals), -1);
  rb_define_method(SwigClassTubeMeshGenerator.klass, "set_num_tex_coord_set", VALUEFUNC(_wrap_TubeMeshGenerator_set_num_tex_coord_set), -1);
  rb_define_method(SwigClassTubeMeshGenerator.klass, "set_switch_uv", VALUEFUNC(_wrap_TubeMeshGenerator_set_switch_uv), -1);
  rb_define_method(SwigClassTubeMeshGenerator.klass, "set_orientation", VALUEFUNC(_wrap_TubeMeshGenerator_set_orientation), -1);
  rb_define_method(SwigClassTubeMeshGenerator.klass, "set_position", VALUEFUNC(_wrap_TubeMeshGenerator_set_position), -1);
  rb_define_method(SwigClassTubeMeshGenerator.klass, "set_scale", VALUEFUNC(_wrap_TubeMeshGenerator_set_scale), -1);
  rb_define_method(SwigClassTubeMeshGenerator.klass, "reset_transforms", VALUEFUNC(_wrap_TubeMeshGenerator_reset_transforms), -1);
  rb_define_method(SwigClassTubeMeshGenerator.klass, "_set_dump_to_file", VALUEFUNC(_wrap_TubeMeshGenerator__set_dump_to_file), -1);
  rb_define_method(SwigClassTubeMeshGenerator.klass, "_disable_dump_to_file", VALUEFUNC(_wrap_TubeMeshGenerator__disable_dump_to_file), -1);
  SwigClassTubeMeshGenerator.mark = 0;
  SwigClassTubeMeshGenerator.destroy = (void (*)(void *)) free_Procedural_MeshGenerator_Sl_Procedural_TubeGenerator_Sg_;
  SwigClassTubeMeshGenerator.trackObjects = 0;
  
  SwigClassTubeGenerator.klass = rb_define_class_under(mProcedural, "TubeGenerator", ((swig_class *) SWIGTYPE_p_Procedural__MeshGeneratorT_Procedural__TubeGenerator_t->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__TubeGenerator, (void *) &SwigClassTubeGenerator);
  rb_define_alloc_func(SwigClassTubeGenerator.klass, _wrap_TubeGenerator_allocate);
  rb_define_method(SwigClassTubeGenerator.klass, "initialize", VALUEFUNC(_wrap_new_TubeGenerator), -1);
  rb_define_method(SwigClassTubeGenerator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_TubeGenerator_add_to_triangle_buffer), -1);
  rb_define_method(SwigClassTubeGenerator.klass, "set_num_seg_base", VALUEFUNC(_wrap_TubeGenerator_set_num_seg_base), -1);
  rb_define_method(SwigClassTubeGenerator.klass, "set_num_seg_height", VALUEFUNC(_wrap_TubeGenerator_set_num_seg_height), -1);
  rb_define_method(SwigClassTubeGenerator.klass, "set_outer_radius", VALUEFUNC(_wrap_TubeGenerator_set_outer_radius), -1);
  rb_define_method(SwigClassTubeGenerator.klass, "set_inner_radius", VALUEFUNC(_wrap_TubeGenerator_set_inner_radius), -1);
  rb_define_method(SwigClassTubeGenerator.klass, "set_height", VALUEFUNC(_wrap_TubeGenerator_set_height), -1);
  SwigClassTubeGenerator.mark = 0;
  SwigClassTubeGenerator.destroy = (void (*)(void *)) free_Procedural_TubeGenerator;
  SwigClassTubeGenerator.trackObjects = 0;
  
  SwigClassTrack.klass = rb_define_class_under(mProcedural, "Track", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__Track, (void *) &SwigClassTrack);
  rb_define_alloc_func(SwigClassTrack.klass, _wrap_Track_allocate);
  rb_define_method(SwigClassTrack.klass, "initialize", VALUEFUNC(_wrap_new_Track), -1);
  rb_define_const(SwigClassTrack.klass, "AM_ABSOLUTE_LINEIC", SWIG_From_int(static_cast< int >(Procedural::Track::AM_ABSOLUTE_LINEIC)));
  rb_define_const(SwigClassTrack.klass, "AM_RELATIVE_LINEIC", SWIG_From_int(static_cast< int >(Procedural::Track::AM_RELATIVE_LINEIC)));
  rb_define_const(SwigClassTrack.klass, "AM_POINT", SWIG_From_int(static_cast< int >(Procedural::Track::AM_POINT)));
  rb_define_method(SwigClassTrack.klass, "get_addressing_mode", VALUEFUNC(_wrap_Track_get_addressing_mode), -1);
  rb_define_method(SwigClassTrack.klass, "add_key_frame", VALUEFUNC(_wrap_Track_add_key_frame), -1);
  rb_define_method(SwigClassTrack.klass, "is_insert_point", VALUEFUNC(_wrap_Track_is_insert_point), -1);
  rb_define_method(SwigClassTrack.klass, "get_value", VALUEFUNC(_wrap_Track_get_value), -1);
  rb_define_method(SwigClassTrack.klass, "_get_key_value_before", VALUEFUNC(_wrap_Track__get_key_value_before), -1);
  rb_define_method(SwigClassTrack.klass, "_get_key_value_after", VALUEFUNC(_wrap_Track__get_key_value_after), -1);
  rb_define_method(SwigClassTrack.klass, "get_first_value", VALUEFUNC(_wrap_Track_get_first_value), -1);
  rb_define_method(SwigClassTrack.klass, "get_last_value", VALUEFUNC(_wrap_Track_get_last_value), -1);
  SwigClassTrack.mark = 0;
  SwigClassTrack.destroy = (void (*)(void *)) free_Procedural_Track;
  SwigClassTrack.trackObjects = 0;
  rb_define_const(mProcedural, "SIDE_LEFT", SWIG_From_int(static_cast< int >(Procedural::SIDE_LEFT)));
  rb_define_const(mProcedural, "SIDE_RIGHT", SWIG_From_int(static_cast< int >(Procedural::SIDE_RIGHT)));
  
  SwigClassShape.klass = rb_define_class_under(mProcedural, "Shape", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__Shape, (void *) &SwigClassShape);
  rb_define_alloc_func(SwigClassShape.klass, _wrap_Shape_allocate);
  rb_define_method(SwigClassShape.klass, "initialize", VALUEFUNC(_wrap_new_Shape), -1);
  rb_define_method(SwigClassShape.klass, "add_point", VALUEFUNC(_wrap_Shape_add_point), -1);
  rb_define_method(SwigClassShape.klass, "insert_point", VALUEFUNC(_wrap_Shape_insert_point), -1);
  rb_define_method(SwigClassShape.klass, "add_point_rel", VALUEFUNC(_wrap_Shape_add_point_rel), -1);
  rb_define_method(SwigClassShape.klass, "append_shape", VALUEFUNC(_wrap_Shape_append_shape), -1);
  rb_define_method(SwigClassShape.klass, "append_shape_rel", VALUEFUNC(_wrap_Shape_append_shape_rel), -1);
  rb_define_method(SwigClassShape.klass, "extract_sub_shape", VALUEFUNC(_wrap_Shape_extract_sub_shape), -1);
  rb_define_method(SwigClassShape.klass, "reverse", VALUEFUNC(_wrap_Shape_reverse), -1);
  rb_define_method(SwigClassShape.klass, "reset", VALUEFUNC(_wrap_Shape_reset), -1);
  rb_define_method(SwigClassShape.klass, "convert_to_path", VALUEFUNC(_wrap_Shape_convert_to_path), -1);
  rb_define_method(SwigClassShape.klass, "convert_to_track", VALUEFUNC(_wrap_Shape_convert_to_track), -1);
  rb_define_method(SwigClassShape.klass, "get_points", VALUEFUNC(_wrap_Shape_get_points), -1);
  rb_define_method(SwigClassShape.klass, "get_points_reference", VALUEFUNC(_wrap_Shape_get_points_reference), -1);
  rb_define_method(SwigClassShape.klass, "get_point", VALUEFUNC(_wrap_Shape_get_point), -1);
  rb_define_method(SwigClassShape.klass, "close", VALUEFUNC(_wrap_Shape_close), -1);
  rb_define_method(SwigClassShape.klass, "set_out_side", VALUEFUNC(_wrap_Shape_set_out_side), -1);
  rb_define_method(SwigClassShape.klass, "get_out_side", VALUEFUNC(_wrap_Shape_get_out_side), -1);
  rb_define_method(SwigClassShape.klass, "switch_side", VALUEFUNC(_wrap_Shape_switch_side), -1);
  rb_define_method(SwigClassShape.klass, "get_seg_count", VALUEFUNC(_wrap_Shape_get_seg_count), -1);
  rb_define_method(SwigClassShape.klass, "is_closed", VALUEFUNC(_wrap_Shape_is_closed), -1);
  rb_define_method(SwigClassShape.klass, "get_direction_after", VALUEFUNC(_wrap_Shape_get_direction_after), -1);
  rb_define_method(SwigClassShape.klass, "get_direction_before", VALUEFUNC(_wrap_Shape_get_direction_before), -1);
  rb_define_method(SwigClassShape.klass, "get_avg_direction", VALUEFUNC(_wrap_Shape_get_avg_direction), -1);
  rb_define_method(SwigClassShape.klass, "get_normal_after", VALUEFUNC(_wrap_Shape_get_normal_after), -1);
  rb_define_method(SwigClassShape.klass, "get_normal_before", VALUEFUNC(_wrap_Shape_get_normal_before), -1);
  rb_define_method(SwigClassShape.klass, "get_avg_normal", VALUEFUNC(_wrap_Shape_get_avg_normal), -1);
  rb_define_method(SwigClassShape.klass, "realize_mesh", VALUEFUNC(_wrap_Shape_realize_mesh), -1);
  rb_define_method(SwigClassShape.klass, "_append_to_manual_object", VALUEFUNC(_wrap_Shape__append_to_manual_object), -1);
  rb_define_method(SwigClassShape.klass, "is_point_inside", VALUEFUNC(_wrap_Shape_is_point_inside), -1);
  rb_define_method(SwigClassShape.klass, "boolean_intersect", VALUEFUNC(_wrap_Shape_boolean_intersect), -1);
  rb_define_method(SwigClassShape.klass, "boolean_union", VALUEFUNC(_wrap_Shape_boolean_union), -1);
  rb_define_method(SwigClassShape.klass, "boolean_difference", VALUEFUNC(_wrap_Shape_boolean_difference), -1);
  rb_define_method(SwigClassShape.klass, "find_real_out_side", VALUEFUNC(_wrap_Shape_find_real_out_side), -1);
  rb_define_method(SwigClassShape.klass, "is_outside_real_outside", VALUEFUNC(_wrap_Shape_is_outside_real_outside), -1);
  rb_define_method(SwigClassShape.klass, "merge_keys_with_track", VALUEFUNC(_wrap_Shape_merge_keys_with_track), -1);
  rb_define_method(SwigClassShape.klass, "translate", VALUEFUNC(_wrap_Shape_translate), -1);
  rb_define_method(SwigClassShape.klass, "rotate", VALUEFUNC(_wrap_Shape_rotate), -1);
  rb_define_method(SwigClassShape.klass, "scale", VALUEFUNC(_wrap_Shape_scale), -1);
  rb_define_method(SwigClassShape.klass, "reflect", VALUEFUNC(_wrap_Shape_reflect), -1);
  rb_define_method(SwigClassShape.klass, "get_total_length", VALUEFUNC(_wrap_Shape_get_total_length), -1);
  rb_define_method(SwigClassShape.klass, "get_position", VALUEFUNC(_wrap_Shape_get_position), -1);
  rb_define_method(SwigClassShape.klass, "find_bounding_radius", VALUEFUNC(_wrap_Shape_find_bounding_radius), -1);
  rb_define_method(SwigClassShape.klass, "thicken", VALUEFUNC(_wrap_Shape_thicken), -1);
  SwigClassShape.mark = 0;
  SwigClassShape.destroy = (void (*)(void *)) free_Procedural_Shape;
  SwigClassShape.trackObjects = 0;
  rb_define_const(mProcedural, "AT_NONE", SWIG_From_int(static_cast< int >(Procedural::AT_NONE)));
  rb_define_const(mProcedural, "AT_STRAIGHT", SWIG_From_int(static_cast< int >(Procedural::AT_STRAIGHT)));
  rb_define_const(mProcedural, "AT_CATMULL", SWIG_From_int(static_cast< int >(Procedural::AT_CATMULL)));
  
  SwigClassCubicHermiteSpline2.klass = rb_define_class_under(mProcedural, "CubicHermiteSpline2", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__CubicHermiteSpline2, (void *) &SwigClassCubicHermiteSpline2);
  rb_define_alloc_func(SwigClassCubicHermiteSpline2.klass, _wrap_CubicHermiteSpline2_allocate);
  rb_define_method(SwigClassCubicHermiteSpline2.klass, "initialize", VALUEFUNC(_wrap_new_CubicHermiteSpline2), -1);
  rb_define_method(SwigClassCubicHermiteSpline2.klass, "add_point", VALUEFUNC(_wrap_CubicHermiteSpline2_add_point), -1);
  rb_define_method(SwigClassCubicHermiteSpline2.klass, "realize_shape", VALUEFUNC(_wrap_CubicHermiteSpline2_realize_shape), -1);
  SwigClassCubicHermiteSpline2.mark = 0;
  SwigClassCubicHermiteSpline2.destroy = (void (*)(void *)) free_Procedural_CubicHermiteSpline2;
  SwigClassCubicHermiteSpline2.trackObjects = 0;
  
  SwigClassCatmullRomSpline2.klass = rb_define_class_under(mProcedural, "CatmullRomSpline2", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__CatmullRomSpline2, (void *) &SwigClassCatmullRomSpline2);
  rb_define_alloc_func(SwigClassCatmullRomSpline2.klass, _wrap_CatmullRomSpline2_allocate);
  rb_define_method(SwigClassCatmullRomSpline2.klass, "initialize", VALUEFUNC(_wrap_new_CatmullRomSpline2), -1);
  rb_define_method(SwigClassCatmullRomSpline2.klass, "add_point", VALUEFUNC(_wrap_CatmullRomSpline2_add_point), -1);
  rb_define_method(SwigClassCatmullRomSpline2.klass, "realize_shape", VALUEFUNC(_wrap_CatmullRomSpline2_realize_shape), -1);
  SwigClassCatmullRomSpline2.mark = 0;
  SwigClassCatmullRomSpline2.destroy = (void (*)(void *)) free_Procedural_CatmullRomSpline2;
  SwigClassCatmullRomSpline2.trackObjects = 0;
  
  SwigClassKochanekBartelsSpline2.klass = rb_define_class_under(mProcedural, "KochanekBartelsSpline2", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__KochanekBartelsSpline2, (void *) &SwigClassKochanekBartelsSpline2);
  rb_define_alloc_func(SwigClassKochanekBartelsSpline2.klass, _wrap_KochanekBartelsSpline2_allocate);
  rb_define_method(SwigClassKochanekBartelsSpline2.klass, "initialize", VALUEFUNC(_wrap_new_KochanekBartelsSpline2), -1);
  rb_define_method(SwigClassKochanekBartelsSpline2.klass, "add_point", VALUEFUNC(_wrap_KochanekBartelsSpline2_add_point), -1);
  rb_define_method(SwigClassKochanekBartelsSpline2.klass, "realize_shape", VALUEFUNC(_wrap_KochanekBartelsSpline2_realize_shape), -1);
  SwigClassKochanekBartelsSpline2.mark = 0;
  SwigClassKochanekBartelsSpline2.destroy = (void (*)(void *)) free_Procedural_KochanekBartelsSpline2;
  SwigClassKochanekBartelsSpline2.trackObjects = 0;
  
  SwigClassRectangleShape.klass = rb_define_class_under(mProcedural, "RectangleShape", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__RectangleShape, (void *) &SwigClassRectangleShape);
  rb_define_alloc_func(SwigClassRectangleShape.klass, _wrap_RectangleShape_allocate);
  rb_define_method(SwigClassRectangleShape.klass, "initialize", VALUEFUNC(_wrap_new_RectangleShape), -1);
  rb_define_method(SwigClassRectangleShape.klass, "set_width", VALUEFUNC(_wrap_RectangleShape_set_width), -1);
  rb_define_method(SwigClassRectangleShape.klass, "set_height", VALUEFUNC(_wrap_RectangleShape_set_height), -1);
  rb_define_method(SwigClassRectangleShape.klass, "realize_shape", VALUEFUNC(_wrap_RectangleShape_realize_shape), -1);
  SwigClassRectangleShape.mark = 0;
  SwigClassRectangleShape.destroy = (void (*)(void *)) free_Procedural_RectangleShape;
  SwigClassRectangleShape.trackObjects = 0;
  
  SwigClassCircleShape.klass = rb_define_class_under(mProcedural, "CircleShape", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__CircleShape, (void *) &SwigClassCircleShape);
  rb_define_alloc_func(SwigClassCircleShape.klass, _wrap_CircleShape_allocate);
  rb_define_method(SwigClassCircleShape.klass, "initialize", VALUEFUNC(_wrap_new_CircleShape), -1);
  rb_define_method(SwigClassCircleShape.klass, "set_radius", VALUEFUNC(_wrap_CircleShape_set_radius), -1);
  rb_define_method(SwigClassCircleShape.klass, "set_num_seg", VALUEFUNC(_wrap_CircleShape_set_num_seg), -1);
  rb_define_method(SwigClassCircleShape.klass, "realize_shape", VALUEFUNC(_wrap_CircleShape_realize_shape), -1);
  SwigClassCircleShape.mark = 0;
  SwigClassCircleShape.destroy = (void (*)(void *)) free_Procedural_CircleShape;
  SwigClassCircleShape.trackObjects = 0;
  
  SwigClassRoundedCornerSpline2.klass = rb_define_class_under(mProcedural, "RoundedCornerSpline2", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__RoundedCornerSpline2, (void *) &SwigClassRoundedCornerSpline2);
  rb_define_alloc_func(SwigClassRoundedCornerSpline2.klass, _wrap_RoundedCornerSpline2_allocate);
  rb_define_method(SwigClassRoundedCornerSpline2.klass, "initialize", VALUEFUNC(_wrap_new_RoundedCornerSpline2), -1);
  rb_define_method(SwigClassRoundedCornerSpline2.klass, "set_radius", VALUEFUNC(_wrap_RoundedCornerSpline2_set_radius), -1);
  rb_define_method(SwigClassRoundedCornerSpline2.klass, "add_point", VALUEFUNC(_wrap_RoundedCornerSpline2_add_point), -1);
  rb_define_method(SwigClassRoundedCornerSpline2.klass, "realize_shape", VALUEFUNC(_wrap_RoundedCornerSpline2_realize_shape), -1);
  SwigClassRoundedCornerSpline2.mark = 0;
  SwigClassRoundedCornerSpline2.destroy = (void (*)(void *)) free_Procedural_RoundedCornerSpline2;
  SwigClassRoundedCornerSpline2.trackObjects = 0;
  
  SwigClassCircle.klass = rb_define_class_under(mProcedural, "Circle", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__Circle, (void *) &SwigClassCircle);
  rb_undef_alloc_func(SwigClassCircle.klass);
  rb_define_method(SwigClassCircle.klass, "is_point_inside", VALUEFUNC(_wrap_Circle_is_point_inside), -1);
  SwigClassCircle.mark = 0;
  SwigClassCircle.destroy = (void (*)(void *)) free_Procedural_Circle;
  SwigClassCircle.trackObjects = 0;
  
  SwigClassPlane.klass = rb_define_class_under(mProcedural, "Plane", ((swig_class *) SWIGTYPE_p_Ogre__Plane->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__Plane, (void *) &SwigClassPlane);
  rb_define_alloc_func(SwigClassPlane.klass, _wrap_Plane_allocate);
  rb_define_method(SwigClassPlane.klass, "initialize", VALUEFUNC(_wrap_new_Plane), -1);
  SwigClassPlane.mark = 0;
  SwigClassPlane.destroy = (void (*)(void *)) free_Procedural_Plane;
  SwigClassPlane.trackObjects = 0;
  
  SwigClassLine.klass = rb_define_class_under(mProcedural, "Line", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__Line, (void *) &SwigClassLine);
  rb_define_alloc_func(SwigClassLine.klass, _wrap_Line_allocate);
  rb_define_method(SwigClassLine.klass, "initialize", VALUEFUNC(_wrap_new_Line), -1);
  rb_define_method(SwigClassLine.klass, "set_from_2points", VALUEFUNC(_wrap_Line_set_from_2points), -1);
  SwigClassLine.mark = 0;
  SwigClassLine.destroy = (void (*)(void *)) free_Procedural_Line;
  SwigClassLine.trackObjects = 0;
  
  SwigClassLine2D.klass = rb_define_class_under(mProcedural, "Line2D", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__Line2D, (void *) &SwigClassLine2D);
  rb_define_alloc_func(SwigClassLine2D.klass, _wrap_Line2D_allocate);
  rb_define_method(SwigClassLine2D.klass, "initialize", VALUEFUNC(_wrap_new_Line2D), -1);
  rb_define_method(SwigClassLine2D.klass, "set_from_2points", VALUEFUNC(_wrap_Line2D_set_from_2points), -1);
  SwigClassLine2D.mark = 0;
  SwigClassLine2D.destroy = (void (*)(void *)) free_Procedural_Line2D;
  SwigClassLine2D.trackObjects = 0;
  
  SwigClassSegment2D.klass = rb_define_class_under(mProcedural, "Segment2D", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__Segment2D, (void *) &SwigClassSegment2D);
  rb_define_alloc_func(SwigClassSegment2D.klass, _wrap_Segment2D_allocate);
  rb_define_method(SwigClassSegment2D.klass, "initialize", VALUEFUNC(_wrap_new_Segment2D), -1);
  rb_define_method(SwigClassSegment2D.klass, "get_a", VALUEFUNC(_wrap_Segment2D_get_a), -1);
  rb_define_method(SwigClassSegment2D.klass, "get_b", VALUEFUNC(_wrap_Segment2D_get_b), -1);
  SwigClassSegment2D.mark = 0;
  SwigClassSegment2D.destroy = (void (*)(void *)) free_Procedural_Segment2D;
  SwigClassSegment2D.trackObjects = 0;
  
  SwigClassLathe.klass = rb_define_class_under(mProcedural, "Lathe", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__Lathe, (void *) &SwigClassLathe);
  rb_define_alloc_func(SwigClassLathe.klass, _wrap_Lathe_allocate);
  rb_define_method(SwigClassLathe.klass, "initialize", VALUEFUNC(_wrap_new_Lathe), -1);
  rb_define_method(SwigClassLathe.klass, "set_num_seg", VALUEFUNC(_wrap_Lathe_set_num_seg), -1);
  rb_define_method(SwigClassLathe.klass, "set_angle_begin", VALUEFUNC(_wrap_Lathe_set_angle_begin), -1);
  rb_define_method(SwigClassLathe.klass, "set_angle_end", VALUEFUNC(_wrap_Lathe_set_angle_end), -1);
  rb_define_method(SwigClassLathe.klass, "set_closed", VALUEFUNC(_wrap_Lathe_set_closed), -1);
  rb_define_method(SwigClassLathe.klass, "set_capped", VALUEFUNC(_wrap_Lathe_set_capped), -1);
  rb_define_method(SwigClassLathe.klass, "set_shape_to_extrude", VALUEFUNC(_wrap_Lathe_set_shape_to_extrude), -1);
  rb_define_method(SwigClassLathe.klass, "set_multi_shape_to_extrude", VALUEFUNC(_wrap_Lathe_set_multi_shape_to_extrude), -1);
  rb_define_method(SwigClassLathe.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_Lathe_add_to_triangle_buffer), -1);
  SwigClassLathe.mark = 0;
  SwigClassLathe.destroy = (void (*)(void *)) free_Procedural_Lathe;
  SwigClassLathe.trackObjects = 0;
  
  SwigClassPath.klass = rb_define_class_under(mProcedural, "Path", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__Path, (void *) &SwigClassPath);
  rb_define_alloc_func(SwigClassPath.klass, _wrap_Path_allocate);
  rb_define_method(SwigClassPath.klass, "initialize", VALUEFUNC(_wrap_new_Path), -1);
  rb_define_method(SwigClassPath.klass, "add_point", VALUEFUNC(_wrap_Path_add_point), -1);
  rb_define_method(SwigClassPath.klass, "insert_point", VALUEFUNC(_wrap_Path_insert_point), -1);
  rb_define_method(SwigClassPath.klass, "append_path", VALUEFUNC(_wrap_Path_append_path), -1);
  rb_define_method(SwigClassPath.klass, "append_path_rel", VALUEFUNC(_wrap_Path_append_path_rel), -1);
  rb_define_method(SwigClassPath.klass, "reset", VALUEFUNC(_wrap_Path_reset), -1);
  rb_define_method(SwigClassPath.klass, "close", VALUEFUNC(_wrap_Path_close), -1);
  rb_define_method(SwigClassPath.klass, "is_closed", VALUEFUNC(_wrap_Path_is_closed), -1);
  rb_define_method(SwigClassPath.klass, "get_points", VALUEFUNC(_wrap_Path_get_points), -1);
  rb_define_method(SwigClassPath.klass, "get_points_reference", VALUEFUNC(_wrap_Path_get_points_reference), -1);
  rb_define_method(SwigClassPath.klass, "get_point", VALUEFUNC(_wrap_Path_get_point), -1);
  rb_define_method(SwigClassPath.klass, "get_seg_count", VALUEFUNC(_wrap_Path_get_seg_count), -1);
  rb_define_method(SwigClassPath.klass, "get_direction_after", VALUEFUNC(_wrap_Path_get_direction_after), -1);
  rb_define_method(SwigClassPath.klass, "get_direction_before", VALUEFUNC(_wrap_Path_get_direction_before), -1);
  rb_define_method(SwigClassPath.klass, "get_avg_direction", VALUEFUNC(_wrap_Path_get_avg_direction), -1);
  rb_define_method(SwigClassPath.klass, "get_total_length", VALUEFUNC(_wrap_Path_get_total_length), -1);
  rb_define_method(SwigClassPath.klass, "get_position", VALUEFUNC(_wrap_Path_get_position), -1);
  rb_define_method(SwigClassPath.klass, "realize_mesh", VALUEFUNC(_wrap_Path_realize_mesh), -1);
  rb_define_method(SwigClassPath.klass, "merge_keys_with_track", VALUEFUNC(_wrap_Path_merge_keys_with_track), -1);
  rb_define_method(SwigClassPath.klass, "translate", VALUEFUNC(_wrap_Path_translate), -1);
  rb_define_method(SwigClassPath.klass, "scale", VALUEFUNC(_wrap_Path_scale), -1);
  rb_define_method(SwigClassPath.klass, "reflect", VALUEFUNC(_wrap_Path_reflect), -1);
  rb_define_method(SwigClassPath.klass, "extract_sub_path", VALUEFUNC(_wrap_Path_extract_sub_path), -1);
  rb_define_method(SwigClassPath.klass, "reverse", VALUEFUNC(_wrap_Path_reverse), -1);
  SwigClassPath.mark = 0;
  SwigClassPath.destroy = (void (*)(void *)) free_Procedural_Path;
  SwigClassPath.trackObjects = 0;
  
  SwigClassCatmullRomSpline3.klass = rb_define_class_under(mProcedural, "CatmullRomSpline3", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__CatmullRomSpline3, (void *) &SwigClassCatmullRomSpline3);
  rb_define_alloc_func(SwigClassCatmullRomSpline3.klass, _wrap_CatmullRomSpline3_allocate);
  rb_define_method(SwigClassCatmullRomSpline3.klass, "initialize", VALUEFUNC(_wrap_new_CatmullRomSpline3), -1);
  rb_define_method(SwigClassCatmullRomSpline3.klass, "to_simple_spline", VALUEFUNC(_wrap_CatmullRomSpline3_to_simple_spline), -1);
  rb_define_method(SwigClassCatmullRomSpline3.klass, "add_point", VALUEFUNC(_wrap_CatmullRomSpline3_add_point), -1);
  rb_define_method(SwigClassCatmullRomSpline3.klass, "realize_path", VALUEFUNC(_wrap_CatmullRomSpline3_realize_path), -1);
  SwigClassCatmullRomSpline3.mark = 0;
  SwigClassCatmullRomSpline3.destroy = (void (*)(void *)) free_Procedural_CatmullRomSpline3;
  SwigClassCatmullRomSpline3.trackObjects = 0;
  
  SwigClassCubicHermiteSpline3.klass = rb_define_class_under(mProcedural, "CubicHermiteSpline3", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__CubicHermiteSpline3, (void *) &SwigClassCubicHermiteSpline3);
  rb_define_alloc_func(SwigClassCubicHermiteSpline3.klass, _wrap_CubicHermiteSpline3_allocate);
  rb_define_method(SwigClassCubicHermiteSpline3.klass, "initialize", VALUEFUNC(_wrap_new_CubicHermiteSpline3), -1);
  rb_define_method(SwigClassCubicHermiteSpline3.klass, "add_point", VALUEFUNC(_wrap_CubicHermiteSpline3_add_point), -1);
  rb_define_method(SwigClassCubicHermiteSpline3.klass, "realize_path", VALUEFUNC(_wrap_CubicHermiteSpline3_realize_path), -1);
  SwigClassCubicHermiteSpline3.mark = 0;
  SwigClassCubicHermiteSpline3.destroy = (void (*)(void *)) free_Procedural_CubicHermiteSpline3;
  SwigClassCubicHermiteSpline3.trackObjects = 0;
  
  SwigClassLinePath.klass = rb_define_class_under(mProcedural, "LinePath", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__LinePath, (void *) &SwigClassLinePath);
  rb_define_alloc_func(SwigClassLinePath.klass, _wrap_LinePath_allocate);
  rb_define_method(SwigClassLinePath.klass, "initialize", VALUEFUNC(_wrap_new_LinePath), -1);
  rb_define_method(SwigClassLinePath.klass, "set_point1", VALUEFUNC(_wrap_LinePath_set_point1), -1);
  rb_define_method(SwigClassLinePath.klass, "set_point2", VALUEFUNC(_wrap_LinePath_set_point2), -1);
  rb_define_method(SwigClassLinePath.klass, "set_num_seg", VALUEFUNC(_wrap_LinePath_set_num_seg), -1);
  rb_define_method(SwigClassLinePath.klass, "between_points", VALUEFUNC(_wrap_LinePath_between_points), -1);
  rb_define_method(SwigClassLinePath.klass, "realize_path", VALUEFUNC(_wrap_LinePath_realize_path), -1);
  SwigClassLinePath.mark = 0;
  SwigClassLinePath.destroy = (void (*)(void *)) free_Procedural_LinePath;
  SwigClassLinePath.trackObjects = 0;
  
  SwigClassRoundedCornerSpline3.klass = rb_define_class_under(mProcedural, "RoundedCornerSpline3", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__RoundedCornerSpline3, (void *) &SwigClassRoundedCornerSpline3);
  rb_define_alloc_func(SwigClassRoundedCornerSpline3.klass, _wrap_RoundedCornerSpline3_allocate);
  rb_define_method(SwigClassRoundedCornerSpline3.klass, "initialize", VALUEFUNC(_wrap_new_RoundedCornerSpline3), -1);
  rb_define_method(SwigClassRoundedCornerSpline3.klass, "set_radius", VALUEFUNC(_wrap_RoundedCornerSpline3_set_radius), -1);
  rb_define_method(SwigClassRoundedCornerSpline3.klass, "add_point", VALUEFUNC(_wrap_RoundedCornerSpline3_add_point), -1);
  rb_define_method(SwigClassRoundedCornerSpline3.klass, "realize_path", VALUEFUNC(_wrap_RoundedCornerSpline3_realize_path), -1);
  SwigClassRoundedCornerSpline3.mark = 0;
  SwigClassRoundedCornerSpline3.destroy = (void (*)(void *)) free_Procedural_RoundedCornerSpline3;
  SwigClassRoundedCornerSpline3.trackObjects = 0;
  
  SwigClassExtruder.klass = rb_define_class_under(mProcedural, "Extruder", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__Extruder, (void *) &SwigClassExtruder);
  rb_define_alloc_func(SwigClassExtruder.klass, _wrap_Extruder_allocate);
  rb_define_method(SwigClassExtruder.klass, "initialize", VALUEFUNC(_wrap_new_Extruder), -1);
  rb_define_method(SwigClassExtruder.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_Extruder_add_to_triangle_buffer), -1);
  rb_define_method(SwigClassExtruder.klass, "set_shape_to_extrude", VALUEFUNC(_wrap_Extruder_set_shape_to_extrude), -1);
  rb_define_method(SwigClassExtruder.klass, "set_multi_shape_to_extrude", VALUEFUNC(_wrap_Extruder_set_multi_shape_to_extrude), -1);
  rb_define_method(SwigClassExtruder.klass, "set_extrusion_path", VALUEFUNC(_wrap_Extruder_set_extrusion_path), -1);
  rb_define_method(SwigClassExtruder.klass, "set_rotation_track", VALUEFUNC(_wrap_Extruder_set_rotation_track), -1);
  rb_define_method(SwigClassExtruder.klass, "set_scale_track", VALUEFUNC(_wrap_Extruder_set_scale_track), -1);
  rb_define_method(SwigClassExtruder.klass, "set_shape_texture_track", VALUEFUNC(_wrap_Extruder_set_shape_texture_track), -1);
  rb_define_method(SwigClassExtruder.klass, "set_path_texture_track", VALUEFUNC(_wrap_Extruder_set_path_texture_track), -1);
  rb_define_method(SwigClassExtruder.klass, "set_capped", VALUEFUNC(_wrap_Extruder_set_capped), -1);
  SwigClassExtruder.mark = 0;
  SwigClassExtruder.destroy = (void (*)(void *)) free_Procedural_Extruder;
  SwigClassExtruder.trackObjects = 0;
  
  SwigClassTriangulator.klass = rb_define_class_under(mProcedural, "Triangulator", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Procedural__Triangulator, (void *) &SwigClassTriangulator);
  rb_define_alloc_func(SwigClassTriangulator.klass, _wrap_Triangulator_allocate);
  rb_define_method(SwigClassTriangulator.klass, "initialize", VALUEFUNC(_wrap_new_Triangulator), -1);
  rb_define_method(SwigClassTriangulator.klass, "set_shape_to_triangulate", VALUEFUNC(_wrap_Triangulator_set_shape_to_triangulate), -1);
  rb_define_method(SwigClassTriangulator.klass, "set_multi_shape_to_triangulate", VALUEFUNC(_wrap_Triangulator_set_multi_shape_to_triangulate), -1);
  rb_define_method(SwigClassTriangulator.klass, "triangulate", VALUEFUNC(_wrap_Triangulator_triangulate), -1);
  rb_define_method(SwigClassTriangulator.klass, "add_to_triangle_buffer", VALUEFUNC(_wrap_Triangulator_add_to_triangle_buffer), -1);
  SwigClassTriangulator.mark = 0;
  SwigClassTriangulator.destroy = (void (*)(void *)) free_Procedural_Triangulator;
  SwigClassTriangulator.trackObjects = 0;
}